diff --git a/.idea/portfolio.iml b/.idea/portfolio.iml
index 5e764c4..30c7838 100644
--- a/.idea/portfolio.iml
+++ b/.idea/portfolio.iml
@@ -5,5 +5,7 @@
     <content url="file://$MODULE_DIR$" />
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="htmx.org" level="application" />
+    <orderEntry type="library" name="bootstrap" level="application" />
   </component>
 </module>
\ No newline at end of file
diff --git a/api/apiRoutes.go b/api/apiRoutes.go
new file mode 100644
index 0000000..641c605
--- /dev/null
+++ b/api/apiRoutes.go
@@ -0,0 +1,14 @@
+package api
+
+import (
+	"net/http"
+	handler2 "portfolio/api/handler"
+)
+
+func ApiRoutes(mux **http.ServeMux) {
+	m := *mux
+	// Register the routes and webHandler
+	m.HandleFunc("/api/", handler2.CatchAllHandler)
+	m.HandleFunc("POST /api/user", handler2.CreateUser)
+	m.HandleFunc("GET /api/user/{id}", handler2.GetUser)
+}
diff --git a/backend/api/handler/errorHandlers.go b/api/handler/errorHandlers.go
similarity index 100%
rename from backend/api/handler/errorHandlers.go
rename to api/handler/errorHandlers.go
diff --git a/api/handler/homepage.go b/api/handler/homepage.go
new file mode 100644
index 0000000..1a82383
--- /dev/null
+++ b/api/handler/homepage.go
@@ -0,0 +1,18 @@
+package handler
+
+import (
+	"html/template"
+	"net/http"
+)
+
+func InitHomepage(w http.ResponseWriter, r *http.Request) {
+	tmpl := template.Must(template.ParseFiles("./frontend/templates/index.html"))
+	err := tmpl.Execute(w, nil)
+	if err != nil {
+		_, err := w.Write([]byte("failed to load"))
+		if err != nil {
+			return
+		}
+		return
+	}
+}
diff --git a/backend/api/handler/mainHandler.go b/api/handler/mainHandler.go
similarity index 100%
rename from backend/api/handler/mainHandler.go
rename to api/handler/mainHandler.go
diff --git a/backend/api/handler/projectHandler.go b/api/handler/projectHandler.go
similarity index 100%
rename from backend/api/handler/projectHandler.go
rename to api/handler/projectHandler.go
diff --git a/backend/api/handler/userHandler.go b/api/handler/userHandler.go
similarity index 91%
rename from backend/api/handler/userHandler.go
rename to api/handler/userHandler.go
index de5094f..d0d5f7d 100644
--- a/backend/api/handler/userHandler.go
+++ b/api/handler/userHandler.go
@@ -4,8 +4,8 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
-	"portfolio/backend/database/ent"
-	"portfolio/backend/database/query"
+	"portfolio/database/ent"
+	"portfolio/database/query"
 	"strconv"
 )
 
diff --git a/api/webRoutes.go b/api/webRoutes.go
new file mode 100644
index 0000000..3b8e8f5
--- /dev/null
+++ b/api/webRoutes.go
@@ -0,0 +1,12 @@
+package api
+
+import (
+	"net/http"
+	"portfolio/api/handler"
+)
+
+func WebRoutes(mux **http.ServeMux) {
+	m := *mux
+	// Register the routes and webHandler
+	m.HandleFunc("GET /{$}", handler.InitHomepage)
+}
diff --git a/backend/database/ent/client.go b/backend/database/ent/client.go
deleted file mode 100644
index 73c876f..0000000
--- a/backend/database/ent/client.go
+++ /dev/null
@@ -1,692 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log"
-	"reflect"
-
-	"portfolio/backend/database/ent/migrate"
-
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-// Client is the client that holds all ent builders.
-type Client struct {
-	config
-	// Schema is the client for creating, migrating and dropping schema.
-	Schema *migrate.Schema
-	// Project is the client for interacting with the Project builders.
-	Project *ProjectClient
-	// Team is the client for interacting with the Team builders.
-	Team *TeamClient
-	// User is the client for interacting with the User builders.
-	User *UserClient
-}
-
-// NewClient creates a new client configured with the given options.
-func NewClient(opts ...Option) *Client {
-	client := &Client{config: newConfig(opts...)}
-	client.init()
-	return client
-}
-
-func (c *Client) init() {
-	c.Schema = migrate.NewSchema(c.driver)
-	c.Project = NewProjectClient(c.config)
-	c.Team = NewTeamClient(c.config)
-	c.User = NewUserClient(c.config)
-}
-
-type (
-	// config is the configuration for the client and its builder.
-	config struct {
-		// driver used for executing database requests.
-		driver dialect.Driver
-		// debug enable a debug logging.
-		debug bool
-		// log used for logging on debug mode.
-		log func(...any)
-		// hooks to execute on mutations.
-		hooks *hooks
-		// interceptors to execute on queries.
-		inters *inters
-	}
-	// Option function to configure the client.
-	Option func(*config)
-)
-
-// newConfig creates a new config for the client.
-func newConfig(opts ...Option) config {
-	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
-	cfg.options(opts...)
-	return cfg
-}
-
-// options applies the options on the config object.
-func (c *config) options(opts ...Option) {
-	for _, opt := range opts {
-		opt(c)
-	}
-	if c.debug {
-		c.driver = dialect.Debug(c.driver, c.log)
-	}
-}
-
-// Debug enables debug logging on the ent.Driver.
-func Debug() Option {
-	return func(c *config) {
-		c.debug = true
-	}
-}
-
-// Log sets the logging function for debug mode.
-func Log(fn func(...any)) Option {
-	return func(c *config) {
-		c.log = fn
-	}
-}
-
-// Driver configures the client driver.
-func Driver(driver dialect.Driver) Option {
-	return func(c *config) {
-		c.driver = driver
-	}
-}
-
-// Open opens a database/sql.DB specified by the driver name and
-// the data source name, and returns a new client attached to it.
-// Optional parameters can be added for configuring the client.
-func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
-	switch driverName {
-	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
-		drv, err := sql.Open(driverName, dataSourceName)
-		if err != nil {
-			return nil, err
-		}
-		return NewClient(append(options, Driver(drv))...), nil
-	default:
-		return nil, fmt.Errorf("unsupported driver: %q", driverName)
-	}
-}
-
-// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
-var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")
-
-// Tx returns a new transactional client. The provided context
-// is used until the transaction is committed or rolled back.
-func (c *Client) Tx(ctx context.Context) (*Tx, error) {
-	if _, ok := c.driver.(*txDriver); ok {
-		return nil, ErrTxStarted
-	}
-	tx, err := newTx(ctx, c.driver)
-	if err != nil {
-		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
-	}
-	cfg := c.config
-	cfg.driver = tx
-	return &Tx{
-		ctx:     ctx,
-		config:  cfg,
-		Project: NewProjectClient(cfg),
-		Team:    NewTeamClient(cfg),
-		User:    NewUserClient(cfg),
-	}, nil
-}
-
-// BeginTx returns a transactional client with specified options.
-func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
-	if _, ok := c.driver.(*txDriver); ok {
-		return nil, errors.New("ent: cannot start a transaction within a transaction")
-	}
-	tx, err := c.driver.(interface {
-		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
-	}).BeginTx(ctx, opts)
-	if err != nil {
-		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
-	}
-	cfg := c.config
-	cfg.driver = &txDriver{tx: tx, drv: c.driver}
-	return &Tx{
-		ctx:     ctx,
-		config:  cfg,
-		Project: NewProjectClient(cfg),
-		Team:    NewTeamClient(cfg),
-		User:    NewUserClient(cfg),
-	}, nil
-}
-
-// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
-//
-//	client.Debug().
-//		Project.
-//		Query().
-//		Count(ctx)
-func (c *Client) Debug() *Client {
-	if c.debug {
-		return c
-	}
-	cfg := c.config
-	cfg.driver = dialect.Debug(c.driver, c.log)
-	client := &Client{config: cfg}
-	client.init()
-	return client
-}
-
-// Close closes the database connection and prevents new queries from starting.
-func (c *Client) Close() error {
-	return c.driver.Close()
-}
-
-// Use adds the mutation hooks to all the entity clients.
-// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
-func (c *Client) Use(hooks ...Hook) {
-	c.Project.Use(hooks...)
-	c.Team.Use(hooks...)
-	c.User.Use(hooks...)
-}
-
-// Intercept adds the query interceptors to all the entity clients.
-// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
-func (c *Client) Intercept(interceptors ...Interceptor) {
-	c.Project.Intercept(interceptors...)
-	c.Team.Intercept(interceptors...)
-	c.User.Intercept(interceptors...)
-}
-
-// Mutate implements the ent.Mutator interface.
-func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
-	switch m := m.(type) {
-	case *ProjectMutation:
-		return c.Project.mutate(ctx, m)
-	case *TeamMutation:
-		return c.Team.mutate(ctx, m)
-	case *UserMutation:
-		return c.User.mutate(ctx, m)
-	default:
-		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
-	}
-}
-
-// ProjectClient is a client for the Project schema.
-type ProjectClient struct {
-	config
-}
-
-// NewProjectClient returns a client for the Project from the given config.
-func NewProjectClient(c config) *ProjectClient {
-	return &ProjectClient{config: c}
-}
-
-// Use adds a list of mutation hooks to the hooks stack.
-// A call to `Use(f, g, h)` equals to `project.Hooks(f(g(h())))`.
-func (c *ProjectClient) Use(hooks ...Hook) {
-	c.hooks.Project = append(c.hooks.Project, hooks...)
-}
-
-// Intercept adds a list of query interceptors to the interceptors stack.
-// A call to `Intercept(f, g, h)` equals to `project.Intercept(f(g(h())))`.
-func (c *ProjectClient) Intercept(interceptors ...Interceptor) {
-	c.inters.Project = append(c.inters.Project, interceptors...)
-}
-
-// Create returns a builder for creating a Project entity.
-func (c *ProjectClient) Create() *ProjectCreate {
-	mutation := newProjectMutation(c.config, OpCreate)
-	return &ProjectCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// CreateBulk returns a builder for creating a bulk of Project entities.
-func (c *ProjectClient) CreateBulk(builders ...*ProjectCreate) *ProjectCreateBulk {
-	return &ProjectCreateBulk{config: c.config, builders: builders}
-}
-
-// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
-// a builder and applies setFunc on it.
-func (c *ProjectClient) MapCreateBulk(slice any, setFunc func(*ProjectCreate, int)) *ProjectCreateBulk {
-	rv := reflect.ValueOf(slice)
-	if rv.Kind() != reflect.Slice {
-		return &ProjectCreateBulk{err: fmt.Errorf("calling to ProjectClient.MapCreateBulk with wrong type %T, need slice", slice)}
-	}
-	builders := make([]*ProjectCreate, rv.Len())
-	for i := 0; i < rv.Len(); i++ {
-		builders[i] = c.Create()
-		setFunc(builders[i], i)
-	}
-	return &ProjectCreateBulk{config: c.config, builders: builders}
-}
-
-// Update returns an update builder for Project.
-func (c *ProjectClient) Update() *ProjectUpdate {
-	mutation := newProjectMutation(c.config, OpUpdate)
-	return &ProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOne returns an update builder for the given entity.
-func (c *ProjectClient) UpdateOne(pr *Project) *ProjectUpdateOne {
-	mutation := newProjectMutation(c.config, OpUpdateOne, withProject(pr))
-	return &ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOneID returns an update builder for the given id.
-func (c *ProjectClient) UpdateOneID(id int) *ProjectUpdateOne {
-	mutation := newProjectMutation(c.config, OpUpdateOne, withProjectID(id))
-	return &ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// Delete returns a delete builder for Project.
-func (c *ProjectClient) Delete() *ProjectDelete {
-	mutation := newProjectMutation(c.config, OpDelete)
-	return &ProjectDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// DeleteOne returns a builder for deleting the given entity.
-func (c *ProjectClient) DeleteOne(pr *Project) *ProjectDeleteOne {
-	return c.DeleteOneID(pr.ID)
-}
-
-// DeleteOneID returns a builder for deleting the given entity by its id.
-func (c *ProjectClient) DeleteOneID(id int) *ProjectDeleteOne {
-	builder := c.Delete().Where(project.ID(id))
-	builder.mutation.id = &id
-	builder.mutation.op = OpDeleteOne
-	return &ProjectDeleteOne{builder}
-}
-
-// Query returns a query builder for Project.
-func (c *ProjectClient) Query() *ProjectQuery {
-	return &ProjectQuery{
-		config: c.config,
-		ctx:    &QueryContext{Type: TypeProject},
-		inters: c.Interceptors(),
-	}
-}
-
-// Get returns a Project entity by its id.
-func (c *ProjectClient) Get(ctx context.Context, id int) (*Project, error) {
-	return c.Query().Where(project.ID(id)).Only(ctx)
-}
-
-// GetX is like Get, but panics if an error occurs.
-func (c *ProjectClient) GetX(ctx context.Context, id int) *Project {
-	obj, err := c.Get(ctx, id)
-	if err != nil {
-		panic(err)
-	}
-	return obj
-}
-
-// QueryTeam queries the team edge of a Project.
-func (c *ProjectClient) QueryTeam(pr *Project) *TeamQuery {
-	query := (&TeamClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := pr.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(project.Table, project.FieldID, id),
-			sqlgraph.To(team.Table, team.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, project.TeamTable, project.TeamColumn),
-		)
-		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
-// Hooks returns the client hooks.
-func (c *ProjectClient) Hooks() []Hook {
-	return c.hooks.Project
-}
-
-// Interceptors returns the client interceptors.
-func (c *ProjectClient) Interceptors() []Interceptor {
-	return c.inters.Project
-}
-
-func (c *ProjectClient) mutate(ctx context.Context, m *ProjectMutation) (Value, error) {
-	switch m.Op() {
-	case OpCreate:
-		return (&ProjectCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdate:
-		return (&ProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdateOne:
-		return (&ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpDelete, OpDeleteOne:
-		return (&ProjectDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
-	default:
-		return nil, fmt.Errorf("ent: unknown Project mutation op: %q", m.Op())
-	}
-}
-
-// TeamClient is a client for the Team schema.
-type TeamClient struct {
-	config
-}
-
-// NewTeamClient returns a client for the Team from the given config.
-func NewTeamClient(c config) *TeamClient {
-	return &TeamClient{config: c}
-}
-
-// Use adds a list of mutation hooks to the hooks stack.
-// A call to `Use(f, g, h)` equals to `team.Hooks(f(g(h())))`.
-func (c *TeamClient) Use(hooks ...Hook) {
-	c.hooks.Team = append(c.hooks.Team, hooks...)
-}
-
-// Intercept adds a list of query interceptors to the interceptors stack.
-// A call to `Intercept(f, g, h)` equals to `team.Intercept(f(g(h())))`.
-func (c *TeamClient) Intercept(interceptors ...Interceptor) {
-	c.inters.Team = append(c.inters.Team, interceptors...)
-}
-
-// Create returns a builder for creating a Team entity.
-func (c *TeamClient) Create() *TeamCreate {
-	mutation := newTeamMutation(c.config, OpCreate)
-	return &TeamCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// CreateBulk returns a builder for creating a bulk of Team entities.
-func (c *TeamClient) CreateBulk(builders ...*TeamCreate) *TeamCreateBulk {
-	return &TeamCreateBulk{config: c.config, builders: builders}
-}
-
-// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
-// a builder and applies setFunc on it.
-func (c *TeamClient) MapCreateBulk(slice any, setFunc func(*TeamCreate, int)) *TeamCreateBulk {
-	rv := reflect.ValueOf(slice)
-	if rv.Kind() != reflect.Slice {
-		return &TeamCreateBulk{err: fmt.Errorf("calling to TeamClient.MapCreateBulk with wrong type %T, need slice", slice)}
-	}
-	builders := make([]*TeamCreate, rv.Len())
-	for i := 0; i < rv.Len(); i++ {
-		builders[i] = c.Create()
-		setFunc(builders[i], i)
-	}
-	return &TeamCreateBulk{config: c.config, builders: builders}
-}
-
-// Update returns an update builder for Team.
-func (c *TeamClient) Update() *TeamUpdate {
-	mutation := newTeamMutation(c.config, OpUpdate)
-	return &TeamUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOne returns an update builder for the given entity.
-func (c *TeamClient) UpdateOne(t *Team) *TeamUpdateOne {
-	mutation := newTeamMutation(c.config, OpUpdateOne, withTeam(t))
-	return &TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOneID returns an update builder for the given id.
-func (c *TeamClient) UpdateOneID(id int) *TeamUpdateOne {
-	mutation := newTeamMutation(c.config, OpUpdateOne, withTeamID(id))
-	return &TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// Delete returns a delete builder for Team.
-func (c *TeamClient) Delete() *TeamDelete {
-	mutation := newTeamMutation(c.config, OpDelete)
-	return &TeamDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// DeleteOne returns a builder for deleting the given entity.
-func (c *TeamClient) DeleteOne(t *Team) *TeamDeleteOne {
-	return c.DeleteOneID(t.ID)
-}
-
-// DeleteOneID returns a builder for deleting the given entity by its id.
-func (c *TeamClient) DeleteOneID(id int) *TeamDeleteOne {
-	builder := c.Delete().Where(team.ID(id))
-	builder.mutation.id = &id
-	builder.mutation.op = OpDeleteOne
-	return &TeamDeleteOne{builder}
-}
-
-// Query returns a query builder for Team.
-func (c *TeamClient) Query() *TeamQuery {
-	return &TeamQuery{
-		config: c.config,
-		ctx:    &QueryContext{Type: TypeTeam},
-		inters: c.Interceptors(),
-	}
-}
-
-// Get returns a Team entity by its id.
-func (c *TeamClient) Get(ctx context.Context, id int) (*Team, error) {
-	return c.Query().Where(team.ID(id)).Only(ctx)
-}
-
-// GetX is like Get, but panics if an error occurs.
-func (c *TeamClient) GetX(ctx context.Context, id int) *Team {
-	obj, err := c.Get(ctx, id)
-	if err != nil {
-		panic(err)
-	}
-	return obj
-}
-
-// QueryProject queries the project edge of a Team.
-func (c *TeamClient) QueryProject(t *Team) *ProjectQuery {
-	query := (&ProjectClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := t.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(team.Table, team.FieldID, id),
-			sqlgraph.To(project.Table, project.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, team.ProjectTable, team.ProjectColumn),
-		)
-		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
-// QueryUsers queries the users edge of a Team.
-func (c *TeamClient) QueryUsers(t *Team) *UserQuery {
-	query := (&UserClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := t.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(team.Table, team.FieldID, id),
-			sqlgraph.To(user.Table, user.FieldID),
-			sqlgraph.Edge(sqlgraph.M2M, true, team.UsersTable, team.UsersPrimaryKey...),
-		)
-		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
-// Hooks returns the client hooks.
-func (c *TeamClient) Hooks() []Hook {
-	return c.hooks.Team
-}
-
-// Interceptors returns the client interceptors.
-func (c *TeamClient) Interceptors() []Interceptor {
-	return c.inters.Team
-}
-
-func (c *TeamClient) mutate(ctx context.Context, m *TeamMutation) (Value, error) {
-	switch m.Op() {
-	case OpCreate:
-		return (&TeamCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdate:
-		return (&TeamUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdateOne:
-		return (&TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpDelete, OpDeleteOne:
-		return (&TeamDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
-	default:
-		return nil, fmt.Errorf("ent: unknown Team mutation op: %q", m.Op())
-	}
-}
-
-// UserClient is a client for the User schema.
-type UserClient struct {
-	config
-}
-
-// NewUserClient returns a client for the User from the given config.
-func NewUserClient(c config) *UserClient {
-	return &UserClient{config: c}
-}
-
-// Use adds a list of mutation hooks to the hooks stack.
-// A call to `Use(f, g, h)` equals to `user.Hooks(f(g(h())))`.
-func (c *UserClient) Use(hooks ...Hook) {
-	c.hooks.User = append(c.hooks.User, hooks...)
-}
-
-// Intercept adds a list of query interceptors to the interceptors stack.
-// A call to `Intercept(f, g, h)` equals to `user.Intercept(f(g(h())))`.
-func (c *UserClient) Intercept(interceptors ...Interceptor) {
-	c.inters.User = append(c.inters.User, interceptors...)
-}
-
-// Create returns a builder for creating a User entity.
-func (c *UserClient) Create() *UserCreate {
-	mutation := newUserMutation(c.config, OpCreate)
-	return &UserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// CreateBulk returns a builder for creating a bulk of User entities.
-func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk {
-	return &UserCreateBulk{config: c.config, builders: builders}
-}
-
-// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
-// a builder and applies setFunc on it.
-func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk {
-	rv := reflect.ValueOf(slice)
-	if rv.Kind() != reflect.Slice {
-		return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)}
-	}
-	builders := make([]*UserCreate, rv.Len())
-	for i := 0; i < rv.Len(); i++ {
-		builders[i] = c.Create()
-		setFunc(builders[i], i)
-	}
-	return &UserCreateBulk{config: c.config, builders: builders}
-}
-
-// Update returns an update builder for User.
-func (c *UserClient) Update() *UserUpdate {
-	mutation := newUserMutation(c.config, OpUpdate)
-	return &UserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOne returns an update builder for the given entity.
-func (c *UserClient) UpdateOne(u *User) *UserUpdateOne {
-	mutation := newUserMutation(c.config, OpUpdateOne, withUser(u))
-	return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// UpdateOneID returns an update builder for the given id.
-func (c *UserClient) UpdateOneID(id int) *UserUpdateOne {
-	mutation := newUserMutation(c.config, OpUpdateOne, withUserID(id))
-	return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// Delete returns a delete builder for User.
-func (c *UserClient) Delete() *UserDelete {
-	mutation := newUserMutation(c.config, OpDelete)
-	return &UserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
-}
-
-// DeleteOne returns a builder for deleting the given entity.
-func (c *UserClient) DeleteOne(u *User) *UserDeleteOne {
-	return c.DeleteOneID(u.ID)
-}
-
-// DeleteOneID returns a builder for deleting the given entity by its id.
-func (c *UserClient) DeleteOneID(id int) *UserDeleteOne {
-	builder := c.Delete().Where(user.ID(id))
-	builder.mutation.id = &id
-	builder.mutation.op = OpDeleteOne
-	return &UserDeleteOne{builder}
-}
-
-// Query returns a query builder for User.
-func (c *UserClient) Query() *UserQuery {
-	return &UserQuery{
-		config: c.config,
-		ctx:    &QueryContext{Type: TypeUser},
-		inters: c.Interceptors(),
-	}
-}
-
-// Get returns a User entity by its id.
-func (c *UserClient) Get(ctx context.Context, id int) (*User, error) {
-	return c.Query().Where(user.ID(id)).Only(ctx)
-}
-
-// GetX is like Get, but panics if an error occurs.
-func (c *UserClient) GetX(ctx context.Context, id int) *User {
-	obj, err := c.Get(ctx, id)
-	if err != nil {
-		panic(err)
-	}
-	return obj
-}
-
-// QueryTeams queries the teams edge of a User.
-func (c *UserClient) QueryTeams(u *User) *TeamQuery {
-	query := (&TeamClient{config: c.config}).Query()
-	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
-		id := u.ID
-		step := sqlgraph.NewStep(
-			sqlgraph.From(user.Table, user.FieldID, id),
-			sqlgraph.To(team.Table, team.FieldID),
-			sqlgraph.Edge(sqlgraph.M2M, false, user.TeamsTable, user.TeamsPrimaryKey...),
-		)
-		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
-		return fromV, nil
-	}
-	return query
-}
-
-// Hooks returns the client hooks.
-func (c *UserClient) Hooks() []Hook {
-	return c.hooks.User
-}
-
-// Interceptors returns the client interceptors.
-func (c *UserClient) Interceptors() []Interceptor {
-	return c.inters.User
-}
-
-func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error) {
-	switch m.Op() {
-	case OpCreate:
-		return (&UserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdate:
-		return (&UserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpUpdateOne:
-		return (&UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
-	case OpDelete, OpDeleteOne:
-		return (&UserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
-	default:
-		return nil, fmt.Errorf("ent: unknown User mutation op: %q", m.Op())
-	}
-}
-
-// hooks and interceptors per client, for fast access.
-type (
-	hooks struct {
-		Project, Team, User []ent.Hook
-	}
-	inters struct {
-		Project, Team, User []ent.Interceptor
-	}
-)
diff --git a/backend/database/ent/ent.go b/backend/database/ent/ent.go
deleted file mode 100644
index eedd443..0000000
--- a/backend/database/ent/ent.go
+++ /dev/null
@@ -1,612 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-	"reflect"
-	"sync"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-// ent aliases to avoid import conflicts in user's code.
-type (
-	Op            = ent.Op
-	Hook          = ent.Hook
-	Value         = ent.Value
-	Query         = ent.Query
-	QueryContext  = ent.QueryContext
-	Querier       = ent.Querier
-	QuerierFunc   = ent.QuerierFunc
-	Interceptor   = ent.Interceptor
-	InterceptFunc = ent.InterceptFunc
-	Traverser     = ent.Traverser
-	TraverseFunc  = ent.TraverseFunc
-	Policy        = ent.Policy
-	Mutator       = ent.Mutator
-	Mutation      = ent.Mutation
-	MutateFunc    = ent.MutateFunc
-)
-
-type clientCtxKey struct{}
-
-// FromContext returns a Client stored inside a context, or nil if there isn't one.
-func FromContext(ctx context.Context) *Client {
-	c, _ := ctx.Value(clientCtxKey{}).(*Client)
-	return c
-}
-
-// NewContext returns a new context with the given Client attached.
-func NewContext(parent context.Context, c *Client) context.Context {
-	return context.WithValue(parent, clientCtxKey{}, c)
-}
-
-type txCtxKey struct{}
-
-// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
-func TxFromContext(ctx context.Context) *Tx {
-	tx, _ := ctx.Value(txCtxKey{}).(*Tx)
-	return tx
-}
-
-// NewTxContext returns a new context with the given Tx attached.
-func NewTxContext(parent context.Context, tx *Tx) context.Context {
-	return context.WithValue(parent, txCtxKey{}, tx)
-}
-
-// OrderFunc applies an ordering on the sql selector.
-// Deprecated: Use Asc/Desc functions or the package builders instead.
-type OrderFunc func(*sql.Selector)
-
-var (
-	initCheck   sync.Once
-	columnCheck sql.ColumnCheck
-)
-
-// columnChecker checks if the column exists in the given table.
-func checkColumn(table, column string) error {
-	initCheck.Do(func() {
-		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
-			project.Table: project.ValidColumn,
-			team.Table:    team.ValidColumn,
-			user.Table:    user.ValidColumn,
-		})
-	})
-	return columnCheck(table, column)
-}
-
-// Asc applies the given fields in ASC order.
-func Asc(fields ...string) func(*sql.Selector) {
-	return func(s *sql.Selector) {
-		for _, f := range fields {
-			if err := checkColumn(s.TableName(), f); err != nil {
-				s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
-			}
-			s.OrderBy(sql.Asc(s.C(f)))
-		}
-	}
-}
-
-// Desc applies the given fields in DESC order.
-func Desc(fields ...string) func(*sql.Selector) {
-	return func(s *sql.Selector) {
-		for _, f := range fields {
-			if err := checkColumn(s.TableName(), f); err != nil {
-				s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
-			}
-			s.OrderBy(sql.Desc(s.C(f)))
-		}
-	}
-}
-
-// AggregateFunc applies an aggregation step on the group-by traversal/selector.
-type AggregateFunc func(*sql.Selector) string
-
-// As is a pseudo aggregation function for renaming another other functions with custom names. For example:
-//
-//	GroupBy(field1, field2).
-//	Aggregate(ent.As(ent.Sum(field1), "sum_field1"), (ent.As(ent.Sum(field2), "sum_field2")).
-//	Scan(ctx, &v)
-func As(fn AggregateFunc, end string) AggregateFunc {
-	return func(s *sql.Selector) string {
-		return sql.As(fn(s), end)
-	}
-}
-
-// Count applies the "count" aggregation function on each group.
-func Count() AggregateFunc {
-	return func(s *sql.Selector) string {
-		return sql.Count("*")
-	}
-}
-
-// Max applies the "max" aggregation function on the given field of each group.
-func Max(field string) AggregateFunc {
-	return func(s *sql.Selector) string {
-		if err := checkColumn(s.TableName(), field); err != nil {
-			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
-			return ""
-		}
-		return sql.Max(s.C(field))
-	}
-}
-
-// Mean applies the "mean" aggregation function on the given field of each group.
-func Mean(field string) AggregateFunc {
-	return func(s *sql.Selector) string {
-		if err := checkColumn(s.TableName(), field); err != nil {
-			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
-			return ""
-		}
-		return sql.Avg(s.C(field))
-	}
-}
-
-// Min applies the "min" aggregation function on the given field of each group.
-func Min(field string) AggregateFunc {
-	return func(s *sql.Selector) string {
-		if err := checkColumn(s.TableName(), field); err != nil {
-			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
-			return ""
-		}
-		return sql.Min(s.C(field))
-	}
-}
-
-// Sum applies the "sum" aggregation function on the given field of each group.
-func Sum(field string) AggregateFunc {
-	return func(s *sql.Selector) string {
-		if err := checkColumn(s.TableName(), field); err != nil {
-			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
-			return ""
-		}
-		return sql.Sum(s.C(field))
-	}
-}
-
-// ValidationError returns when validating a field or edge fails.
-type ValidationError struct {
-	Name string // Field or edge name.
-	err  error
-}
-
-// Error implements the error interface.
-func (e *ValidationError) Error() string {
-	return e.err.Error()
-}
-
-// Unwrap implements the errors.Wrapper interface.
-func (e *ValidationError) Unwrap() error {
-	return e.err
-}
-
-// IsValidationError returns a boolean indicating whether the error is a validation error.
-func IsValidationError(err error) bool {
-	if err == nil {
-		return false
-	}
-	var e *ValidationError
-	return errors.As(err, &e)
-}
-
-// NotFoundError returns when trying to fetch a specific entity and it was not found in the database.
-type NotFoundError struct {
-	label string
-}
-
-// Error implements the error interface.
-func (e *NotFoundError) Error() string {
-	return "ent: " + e.label + " not found"
-}
-
-// IsNotFound returns a boolean indicating whether the error is a not found error.
-func IsNotFound(err error) bool {
-	if err == nil {
-		return false
-	}
-	var e *NotFoundError
-	return errors.As(err, &e)
-}
-
-// MaskNotFound masks not found error.
-func MaskNotFound(err error) error {
-	if IsNotFound(err) {
-		return nil
-	}
-	return err
-}
-
-// NotSingularError returns when trying to fetch a singular entity and more then one was found in the database.
-type NotSingularError struct {
-	label string
-}
-
-// Error implements the error interface.
-func (e *NotSingularError) Error() string {
-	return "ent: " + e.label + " not singular"
-}
-
-// IsNotSingular returns a boolean indicating whether the error is a not singular error.
-func IsNotSingular(err error) bool {
-	if err == nil {
-		return false
-	}
-	var e *NotSingularError
-	return errors.As(err, &e)
-}
-
-// NotLoadedError returns when trying to get a node that was not loaded by the query.
-type NotLoadedError struct {
-	edge string
-}
-
-// Error implements the error interface.
-func (e *NotLoadedError) Error() string {
-	return "ent: " + e.edge + " edge was not loaded"
-}
-
-// IsNotLoaded returns a boolean indicating whether the error is a not loaded error.
-func IsNotLoaded(err error) bool {
-	if err == nil {
-		return false
-	}
-	var e *NotLoadedError
-	return errors.As(err, &e)
-}
-
-// ConstraintError returns when trying to create/update one or more entities and
-// one or more of their constraints failed. For example, violation of edge or
-// field uniqueness.
-type ConstraintError struct {
-	msg  string
-	wrap error
-}
-
-// Error implements the error interface.
-func (e ConstraintError) Error() string {
-	return "ent: constraint failed: " + e.msg
-}
-
-// Unwrap implements the errors.Wrapper interface.
-func (e *ConstraintError) Unwrap() error {
-	return e.wrap
-}
-
-// IsConstraintError returns a boolean indicating whether the error is a constraint failure.
-func IsConstraintError(err error) bool {
-	if err == nil {
-		return false
-	}
-	var e *ConstraintError
-	return errors.As(err, &e)
-}
-
-// selector embedded by the different Select/GroupBy builders.
-type selector struct {
-	label string
-	flds  *[]string
-	fns   []AggregateFunc
-	scan  func(context.Context, any) error
-}
-
-// ScanX is like Scan, but panics if an error occurs.
-func (s *selector) ScanX(ctx context.Context, v any) {
-	if err := s.scan(ctx, v); err != nil {
-		panic(err)
-	}
-}
-
-// Strings returns list of strings from a selector. It is only allowed when selecting one field.
-func (s *selector) Strings(ctx context.Context) ([]string, error) {
-	if len(*s.flds) > 1 {
-		return nil, errors.New("ent: Strings is not achievable when selecting more than 1 field")
-	}
-	var v []string
-	if err := s.scan(ctx, &v); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
-// StringsX is like Strings, but panics if an error occurs.
-func (s *selector) StringsX(ctx context.Context) []string {
-	v, err := s.Strings(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// String returns a single string from a selector. It is only allowed when selecting one field.
-func (s *selector) String(ctx context.Context) (_ string, err error) {
-	var v []string
-	if v, err = s.Strings(ctx); err != nil {
-		return
-	}
-	switch len(v) {
-	case 1:
-		return v[0], nil
-	case 0:
-		err = &NotFoundError{s.label}
-	default:
-		err = fmt.Errorf("ent: Strings returned %d results when one was expected", len(v))
-	}
-	return
-}
-
-// StringX is like String, but panics if an error occurs.
-func (s *selector) StringX(ctx context.Context) string {
-	v, err := s.String(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Ints returns list of ints from a selector. It is only allowed when selecting one field.
-func (s *selector) Ints(ctx context.Context) ([]int, error) {
-	if len(*s.flds) > 1 {
-		return nil, errors.New("ent: Ints is not achievable when selecting more than 1 field")
-	}
-	var v []int
-	if err := s.scan(ctx, &v); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
-// IntsX is like Ints, but panics if an error occurs.
-func (s *selector) IntsX(ctx context.Context) []int {
-	v, err := s.Ints(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Int returns a single int from a selector. It is only allowed when selecting one field.
-func (s *selector) Int(ctx context.Context) (_ int, err error) {
-	var v []int
-	if v, err = s.Ints(ctx); err != nil {
-		return
-	}
-	switch len(v) {
-	case 1:
-		return v[0], nil
-	case 0:
-		err = &NotFoundError{s.label}
-	default:
-		err = fmt.Errorf("ent: Ints returned %d results when one was expected", len(v))
-	}
-	return
-}
-
-// IntX is like Int, but panics if an error occurs.
-func (s *selector) IntX(ctx context.Context) int {
-	v, err := s.Int(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Float64s returns list of float64s from a selector. It is only allowed when selecting one field.
-func (s *selector) Float64s(ctx context.Context) ([]float64, error) {
-	if len(*s.flds) > 1 {
-		return nil, errors.New("ent: Float64s is not achievable when selecting more than 1 field")
-	}
-	var v []float64
-	if err := s.scan(ctx, &v); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
-// Float64sX is like Float64s, but panics if an error occurs.
-func (s *selector) Float64sX(ctx context.Context) []float64 {
-	v, err := s.Float64s(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Float64 returns a single float64 from a selector. It is only allowed when selecting one field.
-func (s *selector) Float64(ctx context.Context) (_ float64, err error) {
-	var v []float64
-	if v, err = s.Float64s(ctx); err != nil {
-		return
-	}
-	switch len(v) {
-	case 1:
-		return v[0], nil
-	case 0:
-		err = &NotFoundError{s.label}
-	default:
-		err = fmt.Errorf("ent: Float64s returned %d results when one was expected", len(v))
-	}
-	return
-}
-
-// Float64X is like Float64, but panics if an error occurs.
-func (s *selector) Float64X(ctx context.Context) float64 {
-	v, err := s.Float64(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Bools returns list of bools from a selector. It is only allowed when selecting one field.
-func (s *selector) Bools(ctx context.Context) ([]bool, error) {
-	if len(*s.flds) > 1 {
-		return nil, errors.New("ent: Bools is not achievable when selecting more than 1 field")
-	}
-	var v []bool
-	if err := s.scan(ctx, &v); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
-// BoolsX is like Bools, but panics if an error occurs.
-func (s *selector) BoolsX(ctx context.Context) []bool {
-	v, err := s.Bools(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Bool returns a single bool from a selector. It is only allowed when selecting one field.
-func (s *selector) Bool(ctx context.Context) (_ bool, err error) {
-	var v []bool
-	if v, err = s.Bools(ctx); err != nil {
-		return
-	}
-	switch len(v) {
-	case 1:
-		return v[0], nil
-	case 0:
-		err = &NotFoundError{s.label}
-	default:
-		err = fmt.Errorf("ent: Bools returned %d results when one was expected", len(v))
-	}
-	return
-}
-
-// BoolX is like Bool, but panics if an error occurs.
-func (s *selector) BoolX(ctx context.Context) bool {
-	v, err := s.Bool(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// withHooks invokes the builder operation with the given hooks, if any.
-func withHooks[V Value, M any, PM interface {
-	*M
-	Mutation
-}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
-	if len(hooks) == 0 {
-		return exec(ctx)
-	}
-	var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-		mutationT, ok := any(m).(PM)
-		if !ok {
-			return nil, fmt.Errorf("unexpected mutation type %T", m)
-		}
-		// Set the mutation to the builder.
-		*mutation = *mutationT
-		return exec(ctx)
-	})
-	for i := len(hooks) - 1; i >= 0; i-- {
-		if hooks[i] == nil {
-			return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
-		}
-		mut = hooks[i](mut)
-	}
-	v, err := mut.Mutate(ctx, mutation)
-	if err != nil {
-		return value, err
-	}
-	nv, ok := v.(V)
-	if !ok {
-		return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
-	}
-	return nv, nil
-}
-
-// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist.
-func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context {
-	if ent.QueryFromContext(ctx) == nil {
-		qc.Op = op
-		ctx = ent.NewQueryContext(ctx, qc)
-	}
-	return ctx
-}
-
-func querierAll[V Value, Q interface {
-	sqlAll(context.Context, ...queryHook) (V, error)
-}]() Querier {
-	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		query, ok := q.(Q)
-		if !ok {
-			return nil, fmt.Errorf("unexpected query type %T", q)
-		}
-		return query.sqlAll(ctx)
-	})
-}
-
-func querierCount[Q interface {
-	sqlCount(context.Context) (int, error)
-}]() Querier {
-	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		query, ok := q.(Q)
-		if !ok {
-			return nil, fmt.Errorf("unexpected query type %T", q)
-		}
-		return query.sqlCount(ctx)
-	})
-}
-
-func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
-	for i := len(inters) - 1; i >= 0; i-- {
-		qr = inters[i].Intercept(qr)
-	}
-	rv, err := qr.Query(ctx, q)
-	if err != nil {
-		return v, err
-	}
-	vt, ok := rv.(V)
-	if !ok {
-		return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
-	}
-	return vt, nil
-}
-
-func scanWithInterceptors[Q1 ent.Query, Q2 interface {
-	sqlScan(context.Context, Q1, any) error
-}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
-	rv := reflect.ValueOf(v)
-	var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		query, ok := q.(Q1)
-		if !ok {
-			return nil, fmt.Errorf("unexpected query type %T", q)
-		}
-		if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
-			return nil, err
-		}
-		if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
-			return rv.Elem().Interface(), nil
-		}
-		return v, nil
-	})
-	for i := len(inters) - 1; i >= 0; i-- {
-		qr = inters[i].Intercept(qr)
-	}
-	vv, err := qr.Query(ctx, rootQuery)
-	if err != nil {
-		return err
-	}
-	switch rv2 := reflect.ValueOf(vv); {
-	case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
-	case rv.Type() == rv2.Type():
-		rv.Elem().Set(rv2.Elem())
-	case rv.Elem().Type() == rv2.Type():
-		rv.Elem().Set(rv2)
-	}
-	return nil
-}
-
-// queryHook describes an internal hook for the different sqlAll methods.
-type queryHook func(context.Context, *sqlgraph.QuerySpec)
diff --git a/backend/database/ent/enttest/enttest.go b/backend/database/ent/enttest/enttest.go
deleted file mode 100644
index de627f9..0000000
--- a/backend/database/ent/enttest/enttest.go
+++ /dev/null
@@ -1,84 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package enttest
-
-import (
-	"context"
-	"portfolio/backend/database/ent"
-	// required by schema hooks.
-	_ "portfolio/backend/database/ent/runtime"
-
-	"portfolio/backend/database/ent/migrate"
-
-	"entgo.io/ent/dialect/sql/schema"
-)
-
-type (
-	// TestingT is the interface that is shared between
-	// testing.T and testing.B and used by enttest.
-	TestingT interface {
-		FailNow()
-		Error(...any)
-	}
-
-	// Option configures client creation.
-	Option func(*options)
-
-	options struct {
-		opts        []ent.Option
-		migrateOpts []schema.MigrateOption
-	}
-)
-
-// WithOptions forwards options to client creation.
-func WithOptions(opts ...ent.Option) Option {
-	return func(o *options) {
-		o.opts = append(o.opts, opts...)
-	}
-}
-
-// WithMigrateOptions forwards options to auto migration.
-func WithMigrateOptions(opts ...schema.MigrateOption) Option {
-	return func(o *options) {
-		o.migrateOpts = append(o.migrateOpts, opts...)
-	}
-}
-
-func newOptions(opts []Option) *options {
-	o := &options{}
-	for _, opt := range opts {
-		opt(o)
-	}
-	return o
-}
-
-// Open calls ent.Open and auto-run migration.
-func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *ent.Client {
-	o := newOptions(opts)
-	c, err := ent.Open(driverName, dataSourceName, o.opts...)
-	if err != nil {
-		t.Error(err)
-		t.FailNow()
-	}
-	migrateSchema(t, c, o)
-	return c
-}
-
-// NewClient calls ent.NewClient and auto-run migration.
-func NewClient(t TestingT, opts ...Option) *ent.Client {
-	o := newOptions(opts)
-	c := ent.NewClient(o.opts...)
-	migrateSchema(t, c, o)
-	return c
-}
-func migrateSchema(t TestingT, c *ent.Client, o *options) {
-	tables, err := schema.CopyTables(migrate.Tables)
-	if err != nil {
-		t.Error(err)
-		t.FailNow()
-	}
-	if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil {
-		t.Error(err)
-		t.FailNow()
-	}
-}
diff --git a/backend/database/ent/hook/hook.go b/backend/database/ent/hook/hook.go
deleted file mode 100644
index 88010fc..0000000
--- a/backend/database/ent/hook/hook.go
+++ /dev/null
@@ -1,222 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package hook
-
-import (
-	"context"
-	"fmt"
-	"portfolio/backend/database/ent"
-)
-
-// The ProjectFunc type is an adapter to allow the use of ordinary
-// function as Project mutator.
-type ProjectFunc func(context.Context, *ent.ProjectMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f ProjectFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.ProjectMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ProjectMutation", m)
-}
-
-// The TeamFunc type is an adapter to allow the use of ordinary
-// function as Team mutator.
-type TeamFunc func(context.Context, *ent.TeamMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f TeamFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.TeamMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.TeamMutation", m)
-}
-
-// The UserFunc type is an adapter to allow the use of ordinary
-// function as User mutator.
-type UserFunc func(context.Context, *ent.UserMutation) (ent.Value, error)
-
-// Mutate calls f(ctx, m).
-func (f UserFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-	if mv, ok := m.(*ent.UserMutation); ok {
-		return f(ctx, mv)
-	}
-	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserMutation", m)
-}
-
-// Condition is a hook condition function.
-type Condition func(context.Context, ent.Mutation) bool
-
-// And groups conditions with the AND operator.
-func And(first, second Condition, rest ...Condition) Condition {
-	return func(ctx context.Context, m ent.Mutation) bool {
-		if !first(ctx, m) || !second(ctx, m) {
-			return false
-		}
-		for _, cond := range rest {
-			if !cond(ctx, m) {
-				return false
-			}
-		}
-		return true
-	}
-}
-
-// Or groups conditions with the OR operator.
-func Or(first, second Condition, rest ...Condition) Condition {
-	return func(ctx context.Context, m ent.Mutation) bool {
-		if first(ctx, m) || second(ctx, m) {
-			return true
-		}
-		for _, cond := range rest {
-			if cond(ctx, m) {
-				return true
-			}
-		}
-		return false
-	}
-}
-
-// Not negates a given condition.
-func Not(cond Condition) Condition {
-	return func(ctx context.Context, m ent.Mutation) bool {
-		return !cond(ctx, m)
-	}
-}
-
-// HasOp is a condition testing mutation operation.
-func HasOp(op ent.Op) Condition {
-	return func(_ context.Context, m ent.Mutation) bool {
-		return m.Op().Is(op)
-	}
-}
-
-// HasAddedFields is a condition validating `.AddedField` on fields.
-func HasAddedFields(field string, fields ...string) Condition {
-	return func(_ context.Context, m ent.Mutation) bool {
-		if _, exists := m.AddedField(field); !exists {
-			return false
-		}
-		for _, field := range fields {
-			if _, exists := m.AddedField(field); !exists {
-				return false
-			}
-		}
-		return true
-	}
-}
-
-// HasClearedFields is a condition validating `.FieldCleared` on fields.
-func HasClearedFields(field string, fields ...string) Condition {
-	return func(_ context.Context, m ent.Mutation) bool {
-		if exists := m.FieldCleared(field); !exists {
-			return false
-		}
-		for _, field := range fields {
-			if exists := m.FieldCleared(field); !exists {
-				return false
-			}
-		}
-		return true
-	}
-}
-
-// HasFields is a condition validating `.Field` on fields.
-func HasFields(field string, fields ...string) Condition {
-	return func(_ context.Context, m ent.Mutation) bool {
-		if _, exists := m.Field(field); !exists {
-			return false
-		}
-		for _, field := range fields {
-			if _, exists := m.Field(field); !exists {
-				return false
-			}
-		}
-		return true
-	}
-}
-
-// If executes the given hook under condition.
-//
-//	hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
-func If(hk ent.Hook, cond Condition) ent.Hook {
-	return func(next ent.Mutator) ent.Mutator {
-		return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
-			if cond(ctx, m) {
-				return hk(next).Mutate(ctx, m)
-			}
-			return next.Mutate(ctx, m)
-		})
-	}
-}
-
-// On executes the given hook only for the given operation.
-//
-//	hook.On(Log, ent.Delete|ent.Create)
-func On(hk ent.Hook, op ent.Op) ent.Hook {
-	return If(hk, HasOp(op))
-}
-
-// Unless skips the given hook only for the given operation.
-//
-//	hook.Unless(Log, ent.Update|ent.UpdateOne)
-func Unless(hk ent.Hook, op ent.Op) ent.Hook {
-	return If(hk, Not(HasOp(op)))
-}
-
-// FixedError is a hook returning a fixed error.
-func FixedError(err error) ent.Hook {
-	return func(ent.Mutator) ent.Mutator {
-		return ent.MutateFunc(func(context.Context, ent.Mutation) (ent.Value, error) {
-			return nil, err
-		})
-	}
-}
-
-// Reject returns a hook that rejects all operations that match op.
-//
-//	func (T) Hooks() []ent.Hook {
-//		return []ent.Hook{
-//			Reject(ent.Delete|ent.Update),
-//		}
-//	}
-func Reject(op ent.Op) ent.Hook {
-	hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
-	return On(hk, op)
-}
-
-// Chain acts as a list of hooks and is effectively immutable.
-// Once created, it will always hold the same set of hooks in the same order.
-type Chain struct {
-	hooks []ent.Hook
-}
-
-// NewChain creates a new chain of hooks.
-func NewChain(hooks ...ent.Hook) Chain {
-	return Chain{append([]ent.Hook(nil), hooks...)}
-}
-
-// Hook chains the list of hooks and returns the final hook.
-func (c Chain) Hook() ent.Hook {
-	return func(mutator ent.Mutator) ent.Mutator {
-		for i := len(c.hooks) - 1; i >= 0; i-- {
-			mutator = c.hooks[i](mutator)
-		}
-		return mutator
-	}
-}
-
-// Append extends a chain, adding the specified hook
-// as the last ones in the mutation flow.
-func (c Chain) Append(hooks ...ent.Hook) Chain {
-	newHooks := make([]ent.Hook, 0, len(c.hooks)+len(hooks))
-	newHooks = append(newHooks, c.hooks...)
-	newHooks = append(newHooks, hooks...)
-	return Chain{newHooks}
-}
-
-// Extend extends a chain, adding the specified chain
-// as the last ones in the mutation flow.
-func (c Chain) Extend(chain Chain) Chain {
-	return c.Append(chain.hooks...)
-}
diff --git a/backend/database/ent/migrate/migrate.go b/backend/database/ent/migrate/migrate.go
deleted file mode 100644
index 1956a6b..0000000
--- a/backend/database/ent/migrate/migrate.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package migrate
-
-import (
-	"context"
-	"fmt"
-	"io"
-
-	"entgo.io/ent/dialect"
-	"entgo.io/ent/dialect/sql/schema"
-)
-
-var (
-	// WithGlobalUniqueID sets the universal ids options to the migration.
-	// If this option is enabled, ent migration will allocate a 1<<32 range
-	// for the ids of each entity (table).
-	// Note that this option cannot be applied on tables that already exist.
-	WithGlobalUniqueID = schema.WithGlobalUniqueID
-	// WithDropColumn sets the drop column option to the migration.
-	// If this option is enabled, ent migration will drop old columns
-	// that were used for both fields and edges. This defaults to false.
-	WithDropColumn = schema.WithDropColumn
-	// WithDropIndex sets the drop index option to the migration.
-	// If this option is enabled, ent migration will drop old indexes
-	// that were defined in the schema. This defaults to false.
-	// Note that unique constraints are defined using `UNIQUE INDEX`,
-	// and therefore, it's recommended to enable this option to get more
-	// flexibility in the schema changes.
-	WithDropIndex = schema.WithDropIndex
-	// WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
-	WithForeignKeys = schema.WithForeignKeys
-)
-
-// Schema is the API for creating, migrating and dropping a schema.
-type Schema struct {
-	drv dialect.Driver
-}
-
-// NewSchema creates a new schema client.
-func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} }
-
-// Create creates all schema resources.
-func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error {
-	return Create(ctx, s, Tables, opts...)
-}
-
-// Create creates all table resources using the given schema driver.
-func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error {
-	migrate, err := schema.NewMigrate(s.drv, opts...)
-	if err != nil {
-		return fmt.Errorf("ent/migrate: %w", err)
-	}
-	return migrate.Create(ctx, tables...)
-}
-
-// WriteTo writes the schema changes to w instead of running them against the database.
-//
-//	if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
-//		log.Fatal(err)
-//	}
-func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error {
-	return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...)
-}
diff --git a/backend/database/ent/migrate/schema.go b/backend/database/ent/migrate/schema.go
deleted file mode 100644
index f0bd4f8..0000000
--- a/backend/database/ent/migrate/schema.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package migrate
-
-import (
-	"entgo.io/ent/dialect/sql/schema"
-	"entgo.io/ent/schema/field"
-)
-
-var (
-	// ProjectsColumns holds the columns for the "projects" table.
-	ProjectsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt, Increment: true},
-		{Name: "name", Type: field.TypeString, Unique: true},
-		{Name: "team_project", Type: field.TypeInt, Nullable: true},
-	}
-	// ProjectsTable holds the schema information for the "projects" table.
-	ProjectsTable = &schema.Table{
-		Name:       "projects",
-		Columns:    ProjectsColumns,
-		PrimaryKey: []*schema.Column{ProjectsColumns[0]},
-		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "projects_teams_project",
-				Columns:    []*schema.Column{ProjectsColumns[2]},
-				RefColumns: []*schema.Column{TeamsColumns[0]},
-				OnDelete:   schema.SetNull,
-			},
-		},
-	}
-	// TeamsColumns holds the columns for the "teams" table.
-	TeamsColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt, Increment: true},
-		{Name: "name", Type: field.TypeString},
-	}
-	// TeamsTable holds the schema information for the "teams" table.
-	TeamsTable = &schema.Table{
-		Name:       "teams",
-		Columns:    TeamsColumns,
-		PrimaryKey: []*schema.Column{TeamsColumns[0]},
-	}
-	// UsersColumns holds the columns for the "users" table.
-	UsersColumns = []*schema.Column{
-		{Name: "id", Type: field.TypeInt, Increment: true},
-		{Name: "name", Type: field.TypeString, Default: "John doe"},
-		{Name: "role", Type: field.TypeEnum, Enums: []string{"admin", "user", "visitor"}},
-	}
-	// UsersTable holds the schema information for the "users" table.
-	UsersTable = &schema.Table{
-		Name:       "users",
-		Columns:    UsersColumns,
-		PrimaryKey: []*schema.Column{UsersColumns[0]},
-	}
-	// UserTeamsColumns holds the columns for the "user_teams" table.
-	UserTeamsColumns = []*schema.Column{
-		{Name: "user_id", Type: field.TypeInt},
-		{Name: "team_id", Type: field.TypeInt},
-	}
-	// UserTeamsTable holds the schema information for the "user_teams" table.
-	UserTeamsTable = &schema.Table{
-		Name:       "user_teams",
-		Columns:    UserTeamsColumns,
-		PrimaryKey: []*schema.Column{UserTeamsColumns[0], UserTeamsColumns[1]},
-		ForeignKeys: []*schema.ForeignKey{
-			{
-				Symbol:     "user_teams_user_id",
-				Columns:    []*schema.Column{UserTeamsColumns[0]},
-				RefColumns: []*schema.Column{UsersColumns[0]},
-				OnDelete:   schema.Cascade,
-			},
-			{
-				Symbol:     "user_teams_team_id",
-				Columns:    []*schema.Column{UserTeamsColumns[1]},
-				RefColumns: []*schema.Column{TeamsColumns[0]},
-				OnDelete:   schema.Cascade,
-			},
-		},
-	}
-	// Tables holds all the tables in the schema.
-	Tables = []*schema.Table{
-		ProjectsTable,
-		TeamsTable,
-		UsersTable,
-		UserTeamsTable,
-	}
-)
-
-func init() {
-	ProjectsTable.ForeignKeys[0].RefTable = TeamsTable
-	UserTeamsTable.ForeignKeys[0].RefTable = UsersTable
-	UserTeamsTable.ForeignKeys[1].RefTable = TeamsTable
-}
diff --git a/backend/database/ent/mutation.go b/backend/database/ent/mutation.go
deleted file mode 100644
index f542828..0000000
--- a/backend/database/ent/mutation.go
+++ /dev/null
@@ -1,1399 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-	"sync"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-)
-
-const (
-	// Operation types.
-	OpCreate    = ent.OpCreate
-	OpDelete    = ent.OpDelete
-	OpDeleteOne = ent.OpDeleteOne
-	OpUpdate    = ent.OpUpdate
-	OpUpdateOne = ent.OpUpdateOne
-
-	// Node types.
-	TypeProject = "Project"
-	TypeTeam    = "Team"
-	TypeUser    = "User"
-)
-
-// ProjectMutation represents an operation that mutates the Project nodes in the graph.
-type ProjectMutation struct {
-	config
-	op            Op
-	typ           string
-	id            *int
-	name          *string
-	clearedFields map[string]struct{}
-	team          *int
-	clearedteam   bool
-	done          bool
-	oldValue      func(context.Context) (*Project, error)
-	predicates    []predicate.Project
-}
-
-var _ ent.Mutation = (*ProjectMutation)(nil)
-
-// projectOption allows management of the mutation configuration using functional options.
-type projectOption func(*ProjectMutation)
-
-// newProjectMutation creates new mutation for the Project entity.
-func newProjectMutation(c config, op Op, opts ...projectOption) *ProjectMutation {
-	m := &ProjectMutation{
-		config:        c,
-		op:            op,
-		typ:           TypeProject,
-		clearedFields: make(map[string]struct{}),
-	}
-	for _, opt := range opts {
-		opt(m)
-	}
-	return m
-}
-
-// withProjectID sets the ID field of the mutation.
-func withProjectID(id int) projectOption {
-	return func(m *ProjectMutation) {
-		var (
-			err   error
-			once  sync.Once
-			value *Project
-		)
-		m.oldValue = func(ctx context.Context) (*Project, error) {
-			once.Do(func() {
-				if m.done {
-					err = errors.New("querying old values post mutation is not allowed")
-				} else {
-					value, err = m.Client().Project.Get(ctx, id)
-				}
-			})
-			return value, err
-		}
-		m.id = &id
-	}
-}
-
-// withProject sets the old Project of the mutation.
-func withProject(node *Project) projectOption {
-	return func(m *ProjectMutation) {
-		m.oldValue = func(context.Context) (*Project, error) {
-			return node, nil
-		}
-		m.id = &node.ID
-	}
-}
-
-// Client returns a new `ent.Client` from the mutation. If the mutation was
-// executed in a transaction (ent.Tx), a transactional client is returned.
-func (m ProjectMutation) Client() *Client {
-	client := &Client{config: m.config}
-	client.init()
-	return client
-}
-
-// Tx returns an `ent.Tx` for mutations that were executed in transactions;
-// it returns an error otherwise.
-func (m ProjectMutation) Tx() (*Tx, error) {
-	if _, ok := m.driver.(*txDriver); !ok {
-		return nil, errors.New("ent: mutation is not running in a transaction")
-	}
-	tx := &Tx{config: m.config}
-	tx.init()
-	return tx, nil
-}
-
-// ID returns the ID value in the mutation. Note that the ID is only available
-// if it was provided to the builder or after it was returned from the database.
-func (m *ProjectMutation) ID() (id int, exists bool) {
-	if m.id == nil {
-		return
-	}
-	return *m.id, true
-}
-
-// IDs queries the database and returns the entity ids that match the mutation's predicate.
-// That means, if the mutation is applied within a transaction with an isolation level such
-// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
-// or updated by the mutation.
-func (m *ProjectMutation) IDs(ctx context.Context) ([]int, error) {
-	switch {
-	case m.op.Is(OpUpdateOne | OpDeleteOne):
-		id, exists := m.ID()
-		if exists {
-			return []int{id}, nil
-		}
-		fallthrough
-	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().Project.Query().Where(m.predicates...).IDs(ctx)
-	default:
-		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
-	}
-}
-
-// SetName sets the "name" field.
-func (m *ProjectMutation) SetName(s string) {
-	m.name = &s
-}
-
-// Name returns the value of the "name" field in the mutation.
-func (m *ProjectMutation) Name() (r string, exists bool) {
-	v := m.name
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldName returns the old "name" field's value of the Project entity.
-// If the Project object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *ProjectMutation) OldName(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldName is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldName requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldName: %w", err)
-	}
-	return oldValue.Name, nil
-}
-
-// ResetName resets all changes to the "name" field.
-func (m *ProjectMutation) ResetName() {
-	m.name = nil
-}
-
-// SetTeamID sets the "team" edge to the Team entity by id.
-func (m *ProjectMutation) SetTeamID(id int) {
-	m.team = &id
-}
-
-// ClearTeam clears the "team" edge to the Team entity.
-func (m *ProjectMutation) ClearTeam() {
-	m.clearedteam = true
-}
-
-// TeamCleared reports if the "team" edge to the Team entity was cleared.
-func (m *ProjectMutation) TeamCleared() bool {
-	return m.clearedteam
-}
-
-// TeamID returns the "team" edge ID in the mutation.
-func (m *ProjectMutation) TeamID() (id int, exists bool) {
-	if m.team != nil {
-		return *m.team, true
-	}
-	return
-}
-
-// TeamIDs returns the "team" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// TeamID instead. It exists only for internal usage by the builders.
-func (m *ProjectMutation) TeamIDs() (ids []int) {
-	if id := m.team; id != nil {
-		ids = append(ids, *id)
-	}
-	return
-}
-
-// ResetTeam resets all changes to the "team" edge.
-func (m *ProjectMutation) ResetTeam() {
-	m.team = nil
-	m.clearedteam = false
-}
-
-// Where appends a list predicates to the ProjectMutation builder.
-func (m *ProjectMutation) Where(ps ...predicate.Project) {
-	m.predicates = append(m.predicates, ps...)
-}
-
-// WhereP appends storage-level predicates to the ProjectMutation builder. Using this method,
-// users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *ProjectMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.Project, len(ps))
-	for i := range ps {
-		p[i] = ps[i]
-	}
-	m.Where(p...)
-}
-
-// Op returns the operation name.
-func (m *ProjectMutation) Op() Op {
-	return m.op
-}
-
-// SetOp allows setting the mutation operation.
-func (m *ProjectMutation) SetOp(op Op) {
-	m.op = op
-}
-
-// Type returns the node type of this mutation (Project).
-func (m *ProjectMutation) Type() string {
-	return m.typ
-}
-
-// Fields returns all fields that were changed during this mutation. Note that in
-// order to get all numeric fields that were incremented/decremented, call
-// AddedFields().
-func (m *ProjectMutation) Fields() []string {
-	fields := make([]string, 0, 1)
-	if m.name != nil {
-		fields = append(fields, project.FieldName)
-	}
-	return fields
-}
-
-// Field returns the value of a field with the given name. The second boolean
-// return value indicates that this field was not set, or was not defined in the
-// schema.
-func (m *ProjectMutation) Field(name string) (ent.Value, bool) {
-	switch name {
-	case project.FieldName:
-		return m.Name()
-	}
-	return nil, false
-}
-
-// OldField returns the old value of the field from the database. An error is
-// returned if the mutation operation is not UpdateOne, or the query to the
-// database failed.
-func (m *ProjectMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
-	switch name {
-	case project.FieldName:
-		return m.OldName(ctx)
-	}
-	return nil, fmt.Errorf("unknown Project field %s", name)
-}
-
-// SetField sets the value of a field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *ProjectMutation) SetField(name string, value ent.Value) error {
-	switch name {
-	case project.FieldName:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetName(v)
-		return nil
-	}
-	return fmt.Errorf("unknown Project field %s", name)
-}
-
-// AddedFields returns all numeric fields that were incremented/decremented during
-// this mutation.
-func (m *ProjectMutation) AddedFields() []string {
-	return nil
-}
-
-// AddedField returns the numeric value that was incremented/decremented on a field
-// with the given name. The second boolean return value indicates that this field
-// was not set, or was not defined in the schema.
-func (m *ProjectMutation) AddedField(name string) (ent.Value, bool) {
-	return nil, false
-}
-
-// AddField adds the value to the field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *ProjectMutation) AddField(name string, value ent.Value) error {
-	switch name {
-	}
-	return fmt.Errorf("unknown Project numeric field %s", name)
-}
-
-// ClearedFields returns all nullable fields that were cleared during this
-// mutation.
-func (m *ProjectMutation) ClearedFields() []string {
-	return nil
-}
-
-// FieldCleared returns a boolean indicating if a field with the given name was
-// cleared in this mutation.
-func (m *ProjectMutation) FieldCleared(name string) bool {
-	_, ok := m.clearedFields[name]
-	return ok
-}
-
-// ClearField clears the value of the field with the given name. It returns an
-// error if the field is not defined in the schema.
-func (m *ProjectMutation) ClearField(name string) error {
-	return fmt.Errorf("unknown Project nullable field %s", name)
-}
-
-// ResetField resets all changes in the mutation for the field with the given name.
-// It returns an error if the field is not defined in the schema.
-func (m *ProjectMutation) ResetField(name string) error {
-	switch name {
-	case project.FieldName:
-		m.ResetName()
-		return nil
-	}
-	return fmt.Errorf("unknown Project field %s", name)
-}
-
-// AddedEdges returns all edge names that were set/added in this mutation.
-func (m *ProjectMutation) AddedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.team != nil {
-		edges = append(edges, project.EdgeTeam)
-	}
-	return edges
-}
-
-// AddedIDs returns all IDs (to other nodes) that were added for the given edge
-// name in this mutation.
-func (m *ProjectMutation) AddedIDs(name string) []ent.Value {
-	switch name {
-	case project.EdgeTeam:
-		if id := m.team; id != nil {
-			return []ent.Value{*id}
-		}
-	}
-	return nil
-}
-
-// RemovedEdges returns all edge names that were removed in this mutation.
-func (m *ProjectMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 1)
-	return edges
-}
-
-// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
-// the given name in this mutation.
-func (m *ProjectMutation) RemovedIDs(name string) []ent.Value {
-	return nil
-}
-
-// ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *ProjectMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.clearedteam {
-		edges = append(edges, project.EdgeTeam)
-	}
-	return edges
-}
-
-// EdgeCleared returns a boolean which indicates if the edge with the given name
-// was cleared in this mutation.
-func (m *ProjectMutation) EdgeCleared(name string) bool {
-	switch name {
-	case project.EdgeTeam:
-		return m.clearedteam
-	}
-	return false
-}
-
-// ClearEdge clears the value of the edge with the given name. It returns an error
-// if that edge is not defined in the schema.
-func (m *ProjectMutation) ClearEdge(name string) error {
-	switch name {
-	case project.EdgeTeam:
-		m.ClearTeam()
-		return nil
-	}
-	return fmt.Errorf("unknown Project unique edge %s", name)
-}
-
-// ResetEdge resets all changes to the edge with the given name in this mutation.
-// It returns an error if the edge is not defined in the schema.
-func (m *ProjectMutation) ResetEdge(name string) error {
-	switch name {
-	case project.EdgeTeam:
-		m.ResetTeam()
-		return nil
-	}
-	return fmt.Errorf("unknown Project edge %s", name)
-}
-
-// TeamMutation represents an operation that mutates the Team nodes in the graph.
-type TeamMutation struct {
-	config
-	op             Op
-	typ            string
-	id             *int
-	name           *string
-	clearedFields  map[string]struct{}
-	project        map[int]struct{}
-	removedproject map[int]struct{}
-	clearedproject bool
-	users          map[int]struct{}
-	removedusers   map[int]struct{}
-	clearedusers   bool
-	done           bool
-	oldValue       func(context.Context) (*Team, error)
-	predicates     []predicate.Team
-}
-
-var _ ent.Mutation = (*TeamMutation)(nil)
-
-// teamOption allows management of the mutation configuration using functional options.
-type teamOption func(*TeamMutation)
-
-// newTeamMutation creates new mutation for the Team entity.
-func newTeamMutation(c config, op Op, opts ...teamOption) *TeamMutation {
-	m := &TeamMutation{
-		config:        c,
-		op:            op,
-		typ:           TypeTeam,
-		clearedFields: make(map[string]struct{}),
-	}
-	for _, opt := range opts {
-		opt(m)
-	}
-	return m
-}
-
-// withTeamID sets the ID field of the mutation.
-func withTeamID(id int) teamOption {
-	return func(m *TeamMutation) {
-		var (
-			err   error
-			once  sync.Once
-			value *Team
-		)
-		m.oldValue = func(ctx context.Context) (*Team, error) {
-			once.Do(func() {
-				if m.done {
-					err = errors.New("querying old values post mutation is not allowed")
-				} else {
-					value, err = m.Client().Team.Get(ctx, id)
-				}
-			})
-			return value, err
-		}
-		m.id = &id
-	}
-}
-
-// withTeam sets the old Team of the mutation.
-func withTeam(node *Team) teamOption {
-	return func(m *TeamMutation) {
-		m.oldValue = func(context.Context) (*Team, error) {
-			return node, nil
-		}
-		m.id = &node.ID
-	}
-}
-
-// Client returns a new `ent.Client` from the mutation. If the mutation was
-// executed in a transaction (ent.Tx), a transactional client is returned.
-func (m TeamMutation) Client() *Client {
-	client := &Client{config: m.config}
-	client.init()
-	return client
-}
-
-// Tx returns an `ent.Tx` for mutations that were executed in transactions;
-// it returns an error otherwise.
-func (m TeamMutation) Tx() (*Tx, error) {
-	if _, ok := m.driver.(*txDriver); !ok {
-		return nil, errors.New("ent: mutation is not running in a transaction")
-	}
-	tx := &Tx{config: m.config}
-	tx.init()
-	return tx, nil
-}
-
-// ID returns the ID value in the mutation. Note that the ID is only available
-// if it was provided to the builder or after it was returned from the database.
-func (m *TeamMutation) ID() (id int, exists bool) {
-	if m.id == nil {
-		return
-	}
-	return *m.id, true
-}
-
-// IDs queries the database and returns the entity ids that match the mutation's predicate.
-// That means, if the mutation is applied within a transaction with an isolation level such
-// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
-// or updated by the mutation.
-func (m *TeamMutation) IDs(ctx context.Context) ([]int, error) {
-	switch {
-	case m.op.Is(OpUpdateOne | OpDeleteOne):
-		id, exists := m.ID()
-		if exists {
-			return []int{id}, nil
-		}
-		fallthrough
-	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().Team.Query().Where(m.predicates...).IDs(ctx)
-	default:
-		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
-	}
-}
-
-// SetName sets the "name" field.
-func (m *TeamMutation) SetName(s string) {
-	m.name = &s
-}
-
-// Name returns the value of the "name" field in the mutation.
-func (m *TeamMutation) Name() (r string, exists bool) {
-	v := m.name
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldName returns the old "name" field's value of the Team entity.
-// If the Team object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *TeamMutation) OldName(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldName is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldName requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldName: %w", err)
-	}
-	return oldValue.Name, nil
-}
-
-// ResetName resets all changes to the "name" field.
-func (m *TeamMutation) ResetName() {
-	m.name = nil
-}
-
-// AddProjectIDs adds the "project" edge to the Project entity by ids.
-func (m *TeamMutation) AddProjectIDs(ids ...int) {
-	if m.project == nil {
-		m.project = make(map[int]struct{})
-	}
-	for i := range ids {
-		m.project[ids[i]] = struct{}{}
-	}
-}
-
-// ClearProject clears the "project" edge to the Project entity.
-func (m *TeamMutation) ClearProject() {
-	m.clearedproject = true
-}
-
-// ProjectCleared reports if the "project" edge to the Project entity was cleared.
-func (m *TeamMutation) ProjectCleared() bool {
-	return m.clearedproject
-}
-
-// RemoveProjectIDs removes the "project" edge to the Project entity by IDs.
-func (m *TeamMutation) RemoveProjectIDs(ids ...int) {
-	if m.removedproject == nil {
-		m.removedproject = make(map[int]struct{})
-	}
-	for i := range ids {
-		delete(m.project, ids[i])
-		m.removedproject[ids[i]] = struct{}{}
-	}
-}
-
-// RemovedProject returns the removed IDs of the "project" edge to the Project entity.
-func (m *TeamMutation) RemovedProjectIDs() (ids []int) {
-	for id := range m.removedproject {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// ProjectIDs returns the "project" edge IDs in the mutation.
-func (m *TeamMutation) ProjectIDs() (ids []int) {
-	for id := range m.project {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// ResetProject resets all changes to the "project" edge.
-func (m *TeamMutation) ResetProject() {
-	m.project = nil
-	m.clearedproject = false
-	m.removedproject = nil
-}
-
-// AddUserIDs adds the "users" edge to the User entity by ids.
-func (m *TeamMutation) AddUserIDs(ids ...int) {
-	if m.users == nil {
-		m.users = make(map[int]struct{})
-	}
-	for i := range ids {
-		m.users[ids[i]] = struct{}{}
-	}
-}
-
-// ClearUsers clears the "users" edge to the User entity.
-func (m *TeamMutation) ClearUsers() {
-	m.clearedusers = true
-}
-
-// UsersCleared reports if the "users" edge to the User entity was cleared.
-func (m *TeamMutation) UsersCleared() bool {
-	return m.clearedusers
-}
-
-// RemoveUserIDs removes the "users" edge to the User entity by IDs.
-func (m *TeamMutation) RemoveUserIDs(ids ...int) {
-	if m.removedusers == nil {
-		m.removedusers = make(map[int]struct{})
-	}
-	for i := range ids {
-		delete(m.users, ids[i])
-		m.removedusers[ids[i]] = struct{}{}
-	}
-}
-
-// RemovedUsers returns the removed IDs of the "users" edge to the User entity.
-func (m *TeamMutation) RemovedUsersIDs() (ids []int) {
-	for id := range m.removedusers {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// UsersIDs returns the "users" edge IDs in the mutation.
-func (m *TeamMutation) UsersIDs() (ids []int) {
-	for id := range m.users {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// ResetUsers resets all changes to the "users" edge.
-func (m *TeamMutation) ResetUsers() {
-	m.users = nil
-	m.clearedusers = false
-	m.removedusers = nil
-}
-
-// Where appends a list predicates to the TeamMutation builder.
-func (m *TeamMutation) Where(ps ...predicate.Team) {
-	m.predicates = append(m.predicates, ps...)
-}
-
-// WhereP appends storage-level predicates to the TeamMutation builder. Using this method,
-// users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *TeamMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.Team, len(ps))
-	for i := range ps {
-		p[i] = ps[i]
-	}
-	m.Where(p...)
-}
-
-// Op returns the operation name.
-func (m *TeamMutation) Op() Op {
-	return m.op
-}
-
-// SetOp allows setting the mutation operation.
-func (m *TeamMutation) SetOp(op Op) {
-	m.op = op
-}
-
-// Type returns the node type of this mutation (Team).
-func (m *TeamMutation) Type() string {
-	return m.typ
-}
-
-// Fields returns all fields that were changed during this mutation. Note that in
-// order to get all numeric fields that were incremented/decremented, call
-// AddedFields().
-func (m *TeamMutation) Fields() []string {
-	fields := make([]string, 0, 1)
-	if m.name != nil {
-		fields = append(fields, team.FieldName)
-	}
-	return fields
-}
-
-// Field returns the value of a field with the given name. The second boolean
-// return value indicates that this field was not set, or was not defined in the
-// schema.
-func (m *TeamMutation) Field(name string) (ent.Value, bool) {
-	switch name {
-	case team.FieldName:
-		return m.Name()
-	}
-	return nil, false
-}
-
-// OldField returns the old value of the field from the database. An error is
-// returned if the mutation operation is not UpdateOne, or the query to the
-// database failed.
-func (m *TeamMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
-	switch name {
-	case team.FieldName:
-		return m.OldName(ctx)
-	}
-	return nil, fmt.Errorf("unknown Team field %s", name)
-}
-
-// SetField sets the value of a field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *TeamMutation) SetField(name string, value ent.Value) error {
-	switch name {
-	case team.FieldName:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetName(v)
-		return nil
-	}
-	return fmt.Errorf("unknown Team field %s", name)
-}
-
-// AddedFields returns all numeric fields that were incremented/decremented during
-// this mutation.
-func (m *TeamMutation) AddedFields() []string {
-	return nil
-}
-
-// AddedField returns the numeric value that was incremented/decremented on a field
-// with the given name. The second boolean return value indicates that this field
-// was not set, or was not defined in the schema.
-func (m *TeamMutation) AddedField(name string) (ent.Value, bool) {
-	return nil, false
-}
-
-// AddField adds the value to the field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *TeamMutation) AddField(name string, value ent.Value) error {
-	switch name {
-	}
-	return fmt.Errorf("unknown Team numeric field %s", name)
-}
-
-// ClearedFields returns all nullable fields that were cleared during this
-// mutation.
-func (m *TeamMutation) ClearedFields() []string {
-	return nil
-}
-
-// FieldCleared returns a boolean indicating if a field with the given name was
-// cleared in this mutation.
-func (m *TeamMutation) FieldCleared(name string) bool {
-	_, ok := m.clearedFields[name]
-	return ok
-}
-
-// ClearField clears the value of the field with the given name. It returns an
-// error if the field is not defined in the schema.
-func (m *TeamMutation) ClearField(name string) error {
-	return fmt.Errorf("unknown Team nullable field %s", name)
-}
-
-// ResetField resets all changes in the mutation for the field with the given name.
-// It returns an error if the field is not defined in the schema.
-func (m *TeamMutation) ResetField(name string) error {
-	switch name {
-	case team.FieldName:
-		m.ResetName()
-		return nil
-	}
-	return fmt.Errorf("unknown Team field %s", name)
-}
-
-// AddedEdges returns all edge names that were set/added in this mutation.
-func (m *TeamMutation) AddedEdges() []string {
-	edges := make([]string, 0, 2)
-	if m.project != nil {
-		edges = append(edges, team.EdgeProject)
-	}
-	if m.users != nil {
-		edges = append(edges, team.EdgeUsers)
-	}
-	return edges
-}
-
-// AddedIDs returns all IDs (to other nodes) that were added for the given edge
-// name in this mutation.
-func (m *TeamMutation) AddedIDs(name string) []ent.Value {
-	switch name {
-	case team.EdgeProject:
-		ids := make([]ent.Value, 0, len(m.project))
-		for id := range m.project {
-			ids = append(ids, id)
-		}
-		return ids
-	case team.EdgeUsers:
-		ids := make([]ent.Value, 0, len(m.users))
-		for id := range m.users {
-			ids = append(ids, id)
-		}
-		return ids
-	}
-	return nil
-}
-
-// RemovedEdges returns all edge names that were removed in this mutation.
-func (m *TeamMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 2)
-	if m.removedproject != nil {
-		edges = append(edges, team.EdgeProject)
-	}
-	if m.removedusers != nil {
-		edges = append(edges, team.EdgeUsers)
-	}
-	return edges
-}
-
-// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
-// the given name in this mutation.
-func (m *TeamMutation) RemovedIDs(name string) []ent.Value {
-	switch name {
-	case team.EdgeProject:
-		ids := make([]ent.Value, 0, len(m.removedproject))
-		for id := range m.removedproject {
-			ids = append(ids, id)
-		}
-		return ids
-	case team.EdgeUsers:
-		ids := make([]ent.Value, 0, len(m.removedusers))
-		for id := range m.removedusers {
-			ids = append(ids, id)
-		}
-		return ids
-	}
-	return nil
-}
-
-// ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *TeamMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 2)
-	if m.clearedproject {
-		edges = append(edges, team.EdgeProject)
-	}
-	if m.clearedusers {
-		edges = append(edges, team.EdgeUsers)
-	}
-	return edges
-}
-
-// EdgeCleared returns a boolean which indicates if the edge with the given name
-// was cleared in this mutation.
-func (m *TeamMutation) EdgeCleared(name string) bool {
-	switch name {
-	case team.EdgeProject:
-		return m.clearedproject
-	case team.EdgeUsers:
-		return m.clearedusers
-	}
-	return false
-}
-
-// ClearEdge clears the value of the edge with the given name. It returns an error
-// if that edge is not defined in the schema.
-func (m *TeamMutation) ClearEdge(name string) error {
-	switch name {
-	}
-	return fmt.Errorf("unknown Team unique edge %s", name)
-}
-
-// ResetEdge resets all changes to the edge with the given name in this mutation.
-// It returns an error if the edge is not defined in the schema.
-func (m *TeamMutation) ResetEdge(name string) error {
-	switch name {
-	case team.EdgeProject:
-		m.ResetProject()
-		return nil
-	case team.EdgeUsers:
-		m.ResetUsers()
-		return nil
-	}
-	return fmt.Errorf("unknown Team edge %s", name)
-}
-
-// UserMutation represents an operation that mutates the User nodes in the graph.
-type UserMutation struct {
-	config
-	op            Op
-	typ           string
-	id            *int
-	name          *string
-	role          *user.Role
-	clearedFields map[string]struct{}
-	teams         map[int]struct{}
-	removedteams  map[int]struct{}
-	clearedteams  bool
-	done          bool
-	oldValue      func(context.Context) (*User, error)
-	predicates    []predicate.User
-}
-
-var _ ent.Mutation = (*UserMutation)(nil)
-
-// userOption allows management of the mutation configuration using functional options.
-type userOption func(*UserMutation)
-
-// newUserMutation creates new mutation for the User entity.
-func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
-	m := &UserMutation{
-		config:        c,
-		op:            op,
-		typ:           TypeUser,
-		clearedFields: make(map[string]struct{}),
-	}
-	for _, opt := range opts {
-		opt(m)
-	}
-	return m
-}
-
-// withUserID sets the ID field of the mutation.
-func withUserID(id int) userOption {
-	return func(m *UserMutation) {
-		var (
-			err   error
-			once  sync.Once
-			value *User
-		)
-		m.oldValue = func(ctx context.Context) (*User, error) {
-			once.Do(func() {
-				if m.done {
-					err = errors.New("querying old values post mutation is not allowed")
-				} else {
-					value, err = m.Client().User.Get(ctx, id)
-				}
-			})
-			return value, err
-		}
-		m.id = &id
-	}
-}
-
-// withUser sets the old User of the mutation.
-func withUser(node *User) userOption {
-	return func(m *UserMutation) {
-		m.oldValue = func(context.Context) (*User, error) {
-			return node, nil
-		}
-		m.id = &node.ID
-	}
-}
-
-// Client returns a new `ent.Client` from the mutation. If the mutation was
-// executed in a transaction (ent.Tx), a transactional client is returned.
-func (m UserMutation) Client() *Client {
-	client := &Client{config: m.config}
-	client.init()
-	return client
-}
-
-// Tx returns an `ent.Tx` for mutations that were executed in transactions;
-// it returns an error otherwise.
-func (m UserMutation) Tx() (*Tx, error) {
-	if _, ok := m.driver.(*txDriver); !ok {
-		return nil, errors.New("ent: mutation is not running in a transaction")
-	}
-	tx := &Tx{config: m.config}
-	tx.init()
-	return tx, nil
-}
-
-// ID returns the ID value in the mutation. Note that the ID is only available
-// if it was provided to the builder or after it was returned from the database.
-func (m *UserMutation) ID() (id int, exists bool) {
-	if m.id == nil {
-		return
-	}
-	return *m.id, true
-}
-
-// IDs queries the database and returns the entity ids that match the mutation's predicate.
-// That means, if the mutation is applied within a transaction with an isolation level such
-// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
-// or updated by the mutation.
-func (m *UserMutation) IDs(ctx context.Context) ([]int, error) {
-	switch {
-	case m.op.Is(OpUpdateOne | OpDeleteOne):
-		id, exists := m.ID()
-		if exists {
-			return []int{id}, nil
-		}
-		fallthrough
-	case m.op.Is(OpUpdate | OpDelete):
-		return m.Client().User.Query().Where(m.predicates...).IDs(ctx)
-	default:
-		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
-	}
-}
-
-// SetName sets the "name" field.
-func (m *UserMutation) SetName(s string) {
-	m.name = &s
-}
-
-// Name returns the value of the "name" field in the mutation.
-func (m *UserMutation) Name() (r string, exists bool) {
-	v := m.name
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldName returns the old "name" field's value of the User entity.
-// If the User object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldName(ctx context.Context) (v string, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldName is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldName requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldName: %w", err)
-	}
-	return oldValue.Name, nil
-}
-
-// ResetName resets all changes to the "name" field.
-func (m *UserMutation) ResetName() {
-	m.name = nil
-}
-
-// SetRole sets the "role" field.
-func (m *UserMutation) SetRole(u user.Role) {
-	m.role = &u
-}
-
-// Role returns the value of the "role" field in the mutation.
-func (m *UserMutation) Role() (r user.Role, exists bool) {
-	v := m.role
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldRole returns the old "role" field's value of the User entity.
-// If the User object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldRole(ctx context.Context) (v user.Role, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldRole is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldRole requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldRole: %w", err)
-	}
-	return oldValue.Role, nil
-}
-
-// ResetRole resets all changes to the "role" field.
-func (m *UserMutation) ResetRole() {
-	m.role = nil
-}
-
-// AddTeamIDs adds the "teams" edge to the Team entity by ids.
-func (m *UserMutation) AddTeamIDs(ids ...int) {
-	if m.teams == nil {
-		m.teams = make(map[int]struct{})
-	}
-	for i := range ids {
-		m.teams[ids[i]] = struct{}{}
-	}
-}
-
-// ClearTeams clears the "teams" edge to the Team entity.
-func (m *UserMutation) ClearTeams() {
-	m.clearedteams = true
-}
-
-// TeamsCleared reports if the "teams" edge to the Team entity was cleared.
-func (m *UserMutation) TeamsCleared() bool {
-	return m.clearedteams
-}
-
-// RemoveTeamIDs removes the "teams" edge to the Team entity by IDs.
-func (m *UserMutation) RemoveTeamIDs(ids ...int) {
-	if m.removedteams == nil {
-		m.removedteams = make(map[int]struct{})
-	}
-	for i := range ids {
-		delete(m.teams, ids[i])
-		m.removedteams[ids[i]] = struct{}{}
-	}
-}
-
-// RemovedTeams returns the removed IDs of the "teams" edge to the Team entity.
-func (m *UserMutation) RemovedTeamsIDs() (ids []int) {
-	for id := range m.removedteams {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// TeamsIDs returns the "teams" edge IDs in the mutation.
-func (m *UserMutation) TeamsIDs() (ids []int) {
-	for id := range m.teams {
-		ids = append(ids, id)
-	}
-	return
-}
-
-// ResetTeams resets all changes to the "teams" edge.
-func (m *UserMutation) ResetTeams() {
-	m.teams = nil
-	m.clearedteams = false
-	m.removedteams = nil
-}
-
-// Where appends a list predicates to the UserMutation builder.
-func (m *UserMutation) Where(ps ...predicate.User) {
-	m.predicates = append(m.predicates, ps...)
-}
-
-// WhereP appends storage-level predicates to the UserMutation builder. Using this method,
-// users can use type-assertion to append predicates that do not depend on any generated package.
-func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) {
-	p := make([]predicate.User, len(ps))
-	for i := range ps {
-		p[i] = ps[i]
-	}
-	m.Where(p...)
-}
-
-// Op returns the operation name.
-func (m *UserMutation) Op() Op {
-	return m.op
-}
-
-// SetOp allows setting the mutation operation.
-func (m *UserMutation) SetOp(op Op) {
-	m.op = op
-}
-
-// Type returns the node type of this mutation (User).
-func (m *UserMutation) Type() string {
-	return m.typ
-}
-
-// Fields returns all fields that were changed during this mutation. Note that in
-// order to get all numeric fields that were incremented/decremented, call
-// AddedFields().
-func (m *UserMutation) Fields() []string {
-	fields := make([]string, 0, 2)
-	if m.name != nil {
-		fields = append(fields, user.FieldName)
-	}
-	if m.role != nil {
-		fields = append(fields, user.FieldRole)
-	}
-	return fields
-}
-
-// Field returns the value of a field with the given name. The second boolean
-// return value indicates that this field was not set, or was not defined in the
-// schema.
-func (m *UserMutation) Field(name string) (ent.Value, bool) {
-	switch name {
-	case user.FieldName:
-		return m.Name()
-	case user.FieldRole:
-		return m.Role()
-	}
-	return nil, false
-}
-
-// OldField returns the old value of the field from the database. An error is
-// returned if the mutation operation is not UpdateOne, or the query to the
-// database failed.
-func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
-	switch name {
-	case user.FieldName:
-		return m.OldName(ctx)
-	case user.FieldRole:
-		return m.OldRole(ctx)
-	}
-	return nil, fmt.Errorf("unknown User field %s", name)
-}
-
-// SetField sets the value of a field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *UserMutation) SetField(name string, value ent.Value) error {
-	switch name {
-	case user.FieldName:
-		v, ok := value.(string)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetName(v)
-		return nil
-	case user.FieldRole:
-		v, ok := value.(user.Role)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetRole(v)
-		return nil
-	}
-	return fmt.Errorf("unknown User field %s", name)
-}
-
-// AddedFields returns all numeric fields that were incremented/decremented during
-// this mutation.
-func (m *UserMutation) AddedFields() []string {
-	return nil
-}
-
-// AddedField returns the numeric value that was incremented/decremented on a field
-// with the given name. The second boolean return value indicates that this field
-// was not set, or was not defined in the schema.
-func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
-	return nil, false
-}
-
-// AddField adds the value to the field with the given name. It returns an error if
-// the field is not defined in the schema, or if the type mismatched the field
-// type.
-func (m *UserMutation) AddField(name string, value ent.Value) error {
-	switch name {
-	}
-	return fmt.Errorf("unknown User numeric field %s", name)
-}
-
-// ClearedFields returns all nullable fields that were cleared during this
-// mutation.
-func (m *UserMutation) ClearedFields() []string {
-	return nil
-}
-
-// FieldCleared returns a boolean indicating if a field with the given name was
-// cleared in this mutation.
-func (m *UserMutation) FieldCleared(name string) bool {
-	_, ok := m.clearedFields[name]
-	return ok
-}
-
-// ClearField clears the value of the field with the given name. It returns an
-// error if the field is not defined in the schema.
-func (m *UserMutation) ClearField(name string) error {
-	return fmt.Errorf("unknown User nullable field %s", name)
-}
-
-// ResetField resets all changes in the mutation for the field with the given name.
-// It returns an error if the field is not defined in the schema.
-func (m *UserMutation) ResetField(name string) error {
-	switch name {
-	case user.FieldName:
-		m.ResetName()
-		return nil
-	case user.FieldRole:
-		m.ResetRole()
-		return nil
-	}
-	return fmt.Errorf("unknown User field %s", name)
-}
-
-// AddedEdges returns all edge names that were set/added in this mutation.
-func (m *UserMutation) AddedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.teams != nil {
-		edges = append(edges, user.EdgeTeams)
-	}
-	return edges
-}
-
-// AddedIDs returns all IDs (to other nodes) that were added for the given edge
-// name in this mutation.
-func (m *UserMutation) AddedIDs(name string) []ent.Value {
-	switch name {
-	case user.EdgeTeams:
-		ids := make([]ent.Value, 0, len(m.teams))
-		for id := range m.teams {
-			ids = append(ids, id)
-		}
-		return ids
-	}
-	return nil
-}
-
-// RemovedEdges returns all edge names that were removed in this mutation.
-func (m *UserMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.removedteams != nil {
-		edges = append(edges, user.EdgeTeams)
-	}
-	return edges
-}
-
-// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
-// the given name in this mutation.
-func (m *UserMutation) RemovedIDs(name string) []ent.Value {
-	switch name {
-	case user.EdgeTeams:
-		ids := make([]ent.Value, 0, len(m.removedteams))
-		for id := range m.removedteams {
-			ids = append(ids, id)
-		}
-		return ids
-	}
-	return nil
-}
-
-// ClearedEdges returns all edge names that were cleared in this mutation.
-func (m *UserMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 1)
-	if m.clearedteams {
-		edges = append(edges, user.EdgeTeams)
-	}
-	return edges
-}
-
-// EdgeCleared returns a boolean which indicates if the edge with the given name
-// was cleared in this mutation.
-func (m *UserMutation) EdgeCleared(name string) bool {
-	switch name {
-	case user.EdgeTeams:
-		return m.clearedteams
-	}
-	return false
-}
-
-// ClearEdge clears the value of the edge with the given name. It returns an error
-// if that edge is not defined in the schema.
-func (m *UserMutation) ClearEdge(name string) error {
-	switch name {
-	}
-	return fmt.Errorf("unknown User unique edge %s", name)
-}
-
-// ResetEdge resets all changes to the edge with the given name in this mutation.
-// It returns an error if the edge is not defined in the schema.
-func (m *UserMutation) ResetEdge(name string) error {
-	switch name {
-	case user.EdgeTeams:
-		m.ResetTeams()
-		return nil
-	}
-	return fmt.Errorf("unknown User edge %s", name)
-}
diff --git a/backend/database/ent/predicate/predicate.go b/backend/database/ent/predicate/predicate.go
deleted file mode 100644
index d248584..0000000
--- a/backend/database/ent/predicate/predicate.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package predicate
-
-import (
-	"entgo.io/ent/dialect/sql"
-)
-
-// Project is the predicate function for project builders.
-type Project func(*sql.Selector)
-
-// Team is the predicate function for team builders.
-type Team func(*sql.Selector)
-
-// User is the predicate function for user builders.
-type User func(*sql.Selector)
diff --git a/backend/database/ent/project.go b/backend/database/ent/project.go
deleted file mode 100644
index 3a39202..0000000
--- a/backend/database/ent/project.go
+++ /dev/null
@@ -1,144 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"strings"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-)
-
-// Project is the model entity for the Project schema.
-type Project struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int `json:"id,omitempty"`
-	// Name holds the value of the "name" field.
-	Name string `json:"name,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the ProjectQuery when eager-loading is set.
-	Edges        ProjectEdges `json:"edges"`
-	team_project *int
-	selectValues sql.SelectValues
-}
-
-// ProjectEdges holds the relations/edges for other nodes in the graph.
-type ProjectEdges struct {
-	// Team holds the value of the team edge.
-	Team *Team `json:"team,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [1]bool
-}
-
-// TeamOrErr returns the Team value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e ProjectEdges) TeamOrErr() (*Team, error) {
-	if e.loadedTypes[0] {
-		if e.Team == nil {
-			// Edge was loaded but was not found.
-			return nil, &NotFoundError{label: team.Label}
-		}
-		return e.Team, nil
-	}
-	return nil, &NotLoadedError{edge: "team"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*Project) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case project.FieldID:
-			values[i] = new(sql.NullInt64)
-		case project.FieldName:
-			values[i] = new(sql.NullString)
-		case project.ForeignKeys[0]: // team_project
-			values[i] = new(sql.NullInt64)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the Project fields.
-func (pr *Project) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case project.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			pr.ID = int(value.Int64)
-		case project.FieldName:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field name", values[i])
-			} else if value.Valid {
-				pr.Name = value.String
-			}
-		case project.ForeignKeys[0]:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for edge-field team_project", value)
-			} else if value.Valid {
-				pr.team_project = new(int)
-				*pr.team_project = int(value.Int64)
-			}
-		default:
-			pr.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the Project.
-// This includes values selected through modifiers, order, etc.
-func (pr *Project) Value(name string) (ent.Value, error) {
-	return pr.selectValues.Get(name)
-}
-
-// QueryTeam queries the "team" edge of the Project entity.
-func (pr *Project) QueryTeam() *TeamQuery {
-	return NewProjectClient(pr.config).QueryTeam(pr)
-}
-
-// Update returns a builder for updating this Project.
-// Note that you need to call Project.Unwrap() before calling this method if this Project
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (pr *Project) Update() *ProjectUpdateOne {
-	return NewProjectClient(pr.config).UpdateOne(pr)
-}
-
-// Unwrap unwraps the Project entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (pr *Project) Unwrap() *Project {
-	_tx, ok := pr.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: Project is not a transactional entity")
-	}
-	pr.config.driver = _tx.drv
-	return pr
-}
-
-// String implements the fmt.Stringer.
-func (pr *Project) String() string {
-	var builder strings.Builder
-	builder.WriteString("Project(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", pr.ID))
-	builder.WriteString("name=")
-	builder.WriteString(pr.Name)
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// Projects is a parsable slice of Project.
-type Projects []*Project
diff --git a/backend/database/ent/project/project.go b/backend/database/ent/project/project.go
deleted file mode 100644
index 9d18f4f..0000000
--- a/backend/database/ent/project/project.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package project
-
-import (
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the project type in the database.
-	Label = "project"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldName holds the string denoting the name field in the database.
-	FieldName = "name"
-	// EdgeTeam holds the string denoting the team edge name in mutations.
-	EdgeTeam = "team"
-	// Table holds the table name of the project in the database.
-	Table = "projects"
-	// TeamTable is the table that holds the team relation/edge.
-	TeamTable = "projects"
-	// TeamInverseTable is the table name for the Team entity.
-	// It exists in this package in order to avoid circular dependency with the "team" package.
-	TeamInverseTable = "teams"
-	// TeamColumn is the table column denoting the team relation/edge.
-	TeamColumn = "team_project"
-)
-
-// Columns holds all SQL columns for project fields.
-var Columns = []string{
-	FieldID,
-	FieldName,
-}
-
-// ForeignKeys holds the SQL foreign-keys that are owned by the "projects"
-// table and are not defined as standalone fields in the schema.
-var ForeignKeys = []string{
-	"team_project",
-}
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	for i := range ForeignKeys {
-		if column == ForeignKeys[i] {
-			return true
-		}
-	}
-	return false
-}
-
-// OrderOption defines the ordering options for the Project queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByName orders the results by the name field.
-func ByName(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldName, opts...).ToFunc()
-}
-
-// ByTeamField orders the results by team field.
-func ByTeamField(field string, opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newTeamStep(), sql.OrderByField(field, opts...))
-	}
-}
-func newTeamStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(TeamInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, TeamTable, TeamColumn),
-	)
-}
diff --git a/backend/database/ent/project/where.go b/backend/database/ent/project/where.go
deleted file mode 100644
index 02fa3de..0000000
--- a/backend/database/ent/project/where.go
+++ /dev/null
@@ -1,163 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package project
-
-import (
-	"portfolio/backend/database/ent/predicate"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int) predicate.Project {
-	return predicate.Project(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int) predicate.Project {
-	return predicate.Project(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int) predicate.Project {
-	return predicate.Project(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int) predicate.Project {
-	return predicate.Project(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int) predicate.Project {
-	return predicate.Project(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int) predicate.Project {
-	return predicate.Project(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int) predicate.Project {
-	return predicate.Project(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int) predicate.Project {
-	return predicate.Project(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int) predicate.Project {
-	return predicate.Project(sql.FieldLTE(FieldID, id))
-}
-
-// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
-func Name(v string) predicate.Project {
-	return predicate.Project(sql.FieldEQ(FieldName, v))
-}
-
-// NameEQ applies the EQ predicate on the "name" field.
-func NameEQ(v string) predicate.Project {
-	return predicate.Project(sql.FieldEQ(FieldName, v))
-}
-
-// NameNEQ applies the NEQ predicate on the "name" field.
-func NameNEQ(v string) predicate.Project {
-	return predicate.Project(sql.FieldNEQ(FieldName, v))
-}
-
-// NameIn applies the In predicate on the "name" field.
-func NameIn(vs ...string) predicate.Project {
-	return predicate.Project(sql.FieldIn(FieldName, vs...))
-}
-
-// NameNotIn applies the NotIn predicate on the "name" field.
-func NameNotIn(vs ...string) predicate.Project {
-	return predicate.Project(sql.FieldNotIn(FieldName, vs...))
-}
-
-// NameGT applies the GT predicate on the "name" field.
-func NameGT(v string) predicate.Project {
-	return predicate.Project(sql.FieldGT(FieldName, v))
-}
-
-// NameGTE applies the GTE predicate on the "name" field.
-func NameGTE(v string) predicate.Project {
-	return predicate.Project(sql.FieldGTE(FieldName, v))
-}
-
-// NameLT applies the LT predicate on the "name" field.
-func NameLT(v string) predicate.Project {
-	return predicate.Project(sql.FieldLT(FieldName, v))
-}
-
-// NameLTE applies the LTE predicate on the "name" field.
-func NameLTE(v string) predicate.Project {
-	return predicate.Project(sql.FieldLTE(FieldName, v))
-}
-
-// NameContains applies the Contains predicate on the "name" field.
-func NameContains(v string) predicate.Project {
-	return predicate.Project(sql.FieldContains(FieldName, v))
-}
-
-// NameHasPrefix applies the HasPrefix predicate on the "name" field.
-func NameHasPrefix(v string) predicate.Project {
-	return predicate.Project(sql.FieldHasPrefix(FieldName, v))
-}
-
-// NameHasSuffix applies the HasSuffix predicate on the "name" field.
-func NameHasSuffix(v string) predicate.Project {
-	return predicate.Project(sql.FieldHasSuffix(FieldName, v))
-}
-
-// NameEqualFold applies the EqualFold predicate on the "name" field.
-func NameEqualFold(v string) predicate.Project {
-	return predicate.Project(sql.FieldEqualFold(FieldName, v))
-}
-
-// NameContainsFold applies the ContainsFold predicate on the "name" field.
-func NameContainsFold(v string) predicate.Project {
-	return predicate.Project(sql.FieldContainsFold(FieldName, v))
-}
-
-// HasTeam applies the HasEdge predicate on the "team" edge.
-func HasTeam() predicate.Project {
-	return predicate.Project(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, TeamTable, TeamColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasTeamWith applies the HasEdge predicate on the "team" edge with a given conditions (other predicates).
-func HasTeamWith(preds ...predicate.Team) predicate.Project {
-	return predicate.Project(func(s *sql.Selector) {
-		step := newTeamStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.Project) predicate.Project {
-	return predicate.Project(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.Project) predicate.Project {
-	return predicate.Project(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.Project) predicate.Project {
-	return predicate.Project(sql.NotPredicates(p))
-}
diff --git a/backend/database/ent/project_create.go b/backend/database/ent/project_create.go
deleted file mode 100644
index 3c6e345..0000000
--- a/backend/database/ent/project_create.go
+++ /dev/null
@@ -1,220 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// ProjectCreate is the builder for creating a Project entity.
-type ProjectCreate struct {
-	config
-	mutation *ProjectMutation
-	hooks    []Hook
-}
-
-// SetName sets the "name" field.
-func (pc *ProjectCreate) SetName(s string) *ProjectCreate {
-	pc.mutation.SetName(s)
-	return pc
-}
-
-// SetTeamID sets the "team" edge to the Team entity by ID.
-func (pc *ProjectCreate) SetTeamID(id int) *ProjectCreate {
-	pc.mutation.SetTeamID(id)
-	return pc
-}
-
-// SetNillableTeamID sets the "team" edge to the Team entity by ID if the given value is not nil.
-func (pc *ProjectCreate) SetNillableTeamID(id *int) *ProjectCreate {
-	if id != nil {
-		pc = pc.SetTeamID(*id)
-	}
-	return pc
-}
-
-// SetTeam sets the "team" edge to the Team entity.
-func (pc *ProjectCreate) SetTeam(t *Team) *ProjectCreate {
-	return pc.SetTeamID(t.ID)
-}
-
-// Mutation returns the ProjectMutation object of the builder.
-func (pc *ProjectCreate) Mutation() *ProjectMutation {
-	return pc.mutation
-}
-
-// Save creates the Project in the database.
-func (pc *ProjectCreate) Save(ctx context.Context) (*Project, error) {
-	return withHooks(ctx, pc.sqlSave, pc.mutation, pc.hooks)
-}
-
-// SaveX calls Save and panics if Save returns an error.
-func (pc *ProjectCreate) SaveX(ctx context.Context) *Project {
-	v, err := pc.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (pc *ProjectCreate) Exec(ctx context.Context) error {
-	_, err := pc.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (pc *ProjectCreate) ExecX(ctx context.Context) {
-	if err := pc.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (pc *ProjectCreate) check() error {
-	if _, ok := pc.mutation.Name(); !ok {
-		return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "Project.name"`)}
-	}
-	return nil
-}
-
-func (pc *ProjectCreate) sqlSave(ctx context.Context) (*Project, error) {
-	if err := pc.check(); err != nil {
-		return nil, err
-	}
-	_node, _spec := pc.createSpec()
-	if err := sqlgraph.CreateNode(ctx, pc.driver, _spec); err != nil {
-		if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	id := _spec.ID.Value.(int64)
-	_node.ID = int(id)
-	pc.mutation.id = &_node.ID
-	pc.mutation.done = true
-	return _node, nil
-}
-
-func (pc *ProjectCreate) createSpec() (*Project, *sqlgraph.CreateSpec) {
-	var (
-		_node = &Project{config: pc.config}
-		_spec = sqlgraph.NewCreateSpec(project.Table, sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt))
-	)
-	if value, ok := pc.mutation.Name(); ok {
-		_spec.SetField(project.FieldName, field.TypeString, value)
-		_node.Name = value
-	}
-	if nodes := pc.mutation.TeamIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   project.TeamTable,
-			Columns: []string{project.TeamColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_node.team_project = &nodes[0]
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	return _node, _spec
-}
-
-// ProjectCreateBulk is the builder for creating many Project entities in bulk.
-type ProjectCreateBulk struct {
-	config
-	err      error
-	builders []*ProjectCreate
-}
-
-// Save creates the Project entities in the database.
-func (pcb *ProjectCreateBulk) Save(ctx context.Context) ([]*Project, error) {
-	if pcb.err != nil {
-		return nil, pcb.err
-	}
-	specs := make([]*sqlgraph.CreateSpec, len(pcb.builders))
-	nodes := make([]*Project, len(pcb.builders))
-	mutators := make([]Mutator, len(pcb.builders))
-	for i := range pcb.builders {
-		func(i int, root context.Context) {
-			builder := pcb.builders[i]
-			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*ProjectMutation)
-				if !ok {
-					return nil, fmt.Errorf("unexpected mutation type %T", m)
-				}
-				if err := builder.check(); err != nil {
-					return nil, err
-				}
-				builder.mutation = mutation
-				var err error
-				nodes[i], specs[i] = builder.createSpec()
-				if i < len(mutators)-1 {
-					_, err = mutators[i+1].Mutate(root, pcb.builders[i+1].mutation)
-				} else {
-					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
-					// Invoke the actual operation on the latest mutation in the chain.
-					if err = sqlgraph.BatchCreate(ctx, pcb.driver, spec); err != nil {
-						if sqlgraph.IsConstraintError(err) {
-							err = &ConstraintError{msg: err.Error(), wrap: err}
-						}
-					}
-				}
-				if err != nil {
-					return nil, err
-				}
-				mutation.id = &nodes[i].ID
-				if specs[i].ID.Value != nil {
-					id := specs[i].ID.Value.(int64)
-					nodes[i].ID = int(id)
-				}
-				mutation.done = true
-				return nodes[i], nil
-			})
-			for i := len(builder.hooks) - 1; i >= 0; i-- {
-				mut = builder.hooks[i](mut)
-			}
-			mutators[i] = mut
-		}(i, ctx)
-	}
-	if len(mutators) > 0 {
-		if _, err := mutators[0].Mutate(ctx, pcb.builders[0].mutation); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (pcb *ProjectCreateBulk) SaveX(ctx context.Context) []*Project {
-	v, err := pcb.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (pcb *ProjectCreateBulk) Exec(ctx context.Context) error {
-	_, err := pcb.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (pcb *ProjectCreateBulk) ExecX(ctx context.Context) {
-	if err := pcb.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/backend/database/ent/project_delete.go b/backend/database/ent/project_delete.go
deleted file mode 100644
index 62ed726..0000000
--- a/backend/database/ent/project_delete.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/project"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// ProjectDelete is the builder for deleting a Project entity.
-type ProjectDelete struct {
-	config
-	hooks    []Hook
-	mutation *ProjectMutation
-}
-
-// Where appends a list predicates to the ProjectDelete builder.
-func (pd *ProjectDelete) Where(ps ...predicate.Project) *ProjectDelete {
-	pd.mutation.Where(ps...)
-	return pd
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (pd *ProjectDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, pd.sqlExec, pd.mutation, pd.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (pd *ProjectDelete) ExecX(ctx context.Context) int {
-	n, err := pd.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (pd *ProjectDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(project.Table, sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt))
-	if ps := pd.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, pd.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	pd.mutation.done = true
-	return affected, err
-}
-
-// ProjectDeleteOne is the builder for deleting a single Project entity.
-type ProjectDeleteOne struct {
-	pd *ProjectDelete
-}
-
-// Where appends a list predicates to the ProjectDelete builder.
-func (pdo *ProjectDeleteOne) Where(ps ...predicate.Project) *ProjectDeleteOne {
-	pdo.pd.mutation.Where(ps...)
-	return pdo
-}
-
-// Exec executes the deletion query.
-func (pdo *ProjectDeleteOne) Exec(ctx context.Context) error {
-	n, err := pdo.pd.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{project.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (pdo *ProjectDeleteOne) ExecX(ctx context.Context) {
-	if err := pdo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/backend/database/ent/project_query.go b/backend/database/ent/project_query.go
deleted file mode 100644
index 09e708e..0000000
--- a/backend/database/ent/project_query.go
+++ /dev/null
@@ -1,613 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"fmt"
-	"math"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// ProjectQuery is the builder for querying Project entities.
-type ProjectQuery struct {
-	config
-	ctx        *QueryContext
-	order      []project.OrderOption
-	inters     []Interceptor
-	predicates []predicate.Project
-	withTeam   *TeamQuery
-	withFKs    bool
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the ProjectQuery builder.
-func (pq *ProjectQuery) Where(ps ...predicate.Project) *ProjectQuery {
-	pq.predicates = append(pq.predicates, ps...)
-	return pq
-}
-
-// Limit the number of records to be returned by this query.
-func (pq *ProjectQuery) Limit(limit int) *ProjectQuery {
-	pq.ctx.Limit = &limit
-	return pq
-}
-
-// Offset to start from.
-func (pq *ProjectQuery) Offset(offset int) *ProjectQuery {
-	pq.ctx.Offset = &offset
-	return pq
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (pq *ProjectQuery) Unique(unique bool) *ProjectQuery {
-	pq.ctx.Unique = &unique
-	return pq
-}
-
-// Order specifies how the records should be ordered.
-func (pq *ProjectQuery) Order(o ...project.OrderOption) *ProjectQuery {
-	pq.order = append(pq.order, o...)
-	return pq
-}
-
-// QueryTeam chains the current query on the "team" edge.
-func (pq *ProjectQuery) QueryTeam() *TeamQuery {
-	query := (&TeamClient{config: pq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := pq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := pq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(project.Table, project.FieldID, selector),
-			sqlgraph.To(team.Table, team.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, project.TeamTable, project.TeamColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(pq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first Project entity from the query.
-// Returns a *NotFoundError when no Project was found.
-func (pq *ProjectQuery) First(ctx context.Context) (*Project, error) {
-	nodes, err := pq.Limit(1).All(setContextOp(ctx, pq.ctx, "First"))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{project.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (pq *ProjectQuery) FirstX(ctx context.Context) *Project {
-	node, err := pq.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first Project ID from the query.
-// Returns a *NotFoundError when no Project ID was found.
-func (pq *ProjectQuery) FirstID(ctx context.Context) (id int, err error) {
-	var ids []int
-	if ids, err = pq.Limit(1).IDs(setContextOp(ctx, pq.ctx, "FirstID")); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{project.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (pq *ProjectQuery) FirstIDX(ctx context.Context) int {
-	id, err := pq.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single Project entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one Project entity is found.
-// Returns a *NotFoundError when no Project entities are found.
-func (pq *ProjectQuery) Only(ctx context.Context) (*Project, error) {
-	nodes, err := pq.Limit(2).All(setContextOp(ctx, pq.ctx, "Only"))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{project.Label}
-	default:
-		return nil, &NotSingularError{project.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (pq *ProjectQuery) OnlyX(ctx context.Context) *Project {
-	node, err := pq.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only Project ID in the query.
-// Returns a *NotSingularError when more than one Project ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (pq *ProjectQuery) OnlyID(ctx context.Context) (id int, err error) {
-	var ids []int
-	if ids, err = pq.Limit(2).IDs(setContextOp(ctx, pq.ctx, "OnlyID")); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{project.Label}
-	default:
-		err = &NotSingularError{project.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (pq *ProjectQuery) OnlyIDX(ctx context.Context) int {
-	id, err := pq.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of Projects.
-func (pq *ProjectQuery) All(ctx context.Context) ([]*Project, error) {
-	ctx = setContextOp(ctx, pq.ctx, "All")
-	if err := pq.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*Project, *ProjectQuery]()
-	return withInterceptors[[]*Project](ctx, pq, qr, pq.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (pq *ProjectQuery) AllX(ctx context.Context) []*Project {
-	nodes, err := pq.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of Project IDs.
-func (pq *ProjectQuery) IDs(ctx context.Context) (ids []int, err error) {
-	if pq.ctx.Unique == nil && pq.path != nil {
-		pq.Unique(true)
-	}
-	ctx = setContextOp(ctx, pq.ctx, "IDs")
-	if err = pq.Select(project.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (pq *ProjectQuery) IDsX(ctx context.Context) []int {
-	ids, err := pq.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (pq *ProjectQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, pq.ctx, "Count")
-	if err := pq.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, pq, querierCount[*ProjectQuery](), pq.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (pq *ProjectQuery) CountX(ctx context.Context) int {
-	count, err := pq.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (pq *ProjectQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, pq.ctx, "Exist")
-	switch _, err := pq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (pq *ProjectQuery) ExistX(ctx context.Context) bool {
-	exist, err := pq.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the ProjectQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (pq *ProjectQuery) Clone() *ProjectQuery {
-	if pq == nil {
-		return nil
-	}
-	return &ProjectQuery{
-		config:     pq.config,
-		ctx:        pq.ctx.Clone(),
-		order:      append([]project.OrderOption{}, pq.order...),
-		inters:     append([]Interceptor{}, pq.inters...),
-		predicates: append([]predicate.Project{}, pq.predicates...),
-		withTeam:   pq.withTeam.Clone(),
-		// clone intermediate query.
-		sql:  pq.sql.Clone(),
-		path: pq.path,
-	}
-}
-
-// WithTeam tells the query-builder to eager-load the nodes that are connected to
-// the "team" edge. The optional arguments are used to configure the query builder of the edge.
-func (pq *ProjectQuery) WithTeam(opts ...func(*TeamQuery)) *ProjectQuery {
-	query := (&TeamClient{config: pq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	pq.withTeam = query
-	return pq
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		Name string `json:"name,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.Project.Query().
-//		GroupBy(project.FieldName).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (pq *ProjectQuery) GroupBy(field string, fields ...string) *ProjectGroupBy {
-	pq.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &ProjectGroupBy{build: pq}
-	grbuild.flds = &pq.ctx.Fields
-	grbuild.label = project.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		Name string `json:"name,omitempty"`
-//	}
-//
-//	client.Project.Query().
-//		Select(project.FieldName).
-//		Scan(ctx, &v)
-func (pq *ProjectQuery) Select(fields ...string) *ProjectSelect {
-	pq.ctx.Fields = append(pq.ctx.Fields, fields...)
-	sbuild := &ProjectSelect{ProjectQuery: pq}
-	sbuild.label = project.Label
-	sbuild.flds, sbuild.scan = &pq.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a ProjectSelect configured with the given aggregations.
-func (pq *ProjectQuery) Aggregate(fns ...AggregateFunc) *ProjectSelect {
-	return pq.Select().Aggregate(fns...)
-}
-
-func (pq *ProjectQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range pq.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, pq); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range pq.ctx.Fields {
-		if !project.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if pq.path != nil {
-		prev, err := pq.path(ctx)
-		if err != nil {
-			return err
-		}
-		pq.sql = prev
-	}
-	return nil
-}
-
-func (pq *ProjectQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Project, error) {
-	var (
-		nodes       = []*Project{}
-		withFKs     = pq.withFKs
-		_spec       = pq.querySpec()
-		loadedTypes = [1]bool{
-			pq.withTeam != nil,
-		}
-	)
-	if pq.withTeam != nil {
-		withFKs = true
-	}
-	if withFKs {
-		_spec.Node.Columns = append(_spec.Node.Columns, project.ForeignKeys...)
-	}
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*Project).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &Project{config: pq.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, pq.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := pq.withTeam; query != nil {
-		if err := pq.loadTeam(ctx, query, nodes, nil,
-			func(n *Project, e *Team) { n.Edges.Team = e }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (pq *ProjectQuery) loadTeam(ctx context.Context, query *TeamQuery, nodes []*Project, init func(*Project), assign func(*Project, *Team)) error {
-	ids := make([]int, 0, len(nodes))
-	nodeids := make(map[int][]*Project)
-	for i := range nodes {
-		if nodes[i].team_project == nil {
-			continue
-		}
-		fk := *nodes[i].team_project
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	query.Where(team.IDIn(ids...))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "team_project" returned %v`, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
-		}
-	}
-	return nil
-}
-
-func (pq *ProjectQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := pq.querySpec()
-	_spec.Node.Columns = pq.ctx.Fields
-	if len(pq.ctx.Fields) > 0 {
-		_spec.Unique = pq.ctx.Unique != nil && *pq.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, pq.driver, _spec)
-}
-
-func (pq *ProjectQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(project.Table, project.Columns, sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt))
-	_spec.From = pq.sql
-	if unique := pq.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if pq.path != nil {
-		_spec.Unique = true
-	}
-	if fields := pq.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, project.FieldID)
-		for i := range fields {
-			if fields[i] != project.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := pq.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := pq.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := pq.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := pq.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (pq *ProjectQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(pq.driver.Dialect())
-	t1 := builder.Table(project.Table)
-	columns := pq.ctx.Fields
-	if len(columns) == 0 {
-		columns = project.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if pq.sql != nil {
-		selector = pq.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if pq.ctx.Unique != nil && *pq.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, p := range pq.predicates {
-		p(selector)
-	}
-	for _, p := range pq.order {
-		p(selector)
-	}
-	if offset := pq.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := pq.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// ProjectGroupBy is the group-by builder for Project entities.
-type ProjectGroupBy struct {
-	selector
-	build *ProjectQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (pgb *ProjectGroupBy) Aggregate(fns ...AggregateFunc) *ProjectGroupBy {
-	pgb.fns = append(pgb.fns, fns...)
-	return pgb
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (pgb *ProjectGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, pgb.build.ctx, "GroupBy")
-	if err := pgb.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*ProjectQuery, *ProjectGroupBy](ctx, pgb.build, pgb, pgb.build.inters, v)
-}
-
-func (pgb *ProjectGroupBy) sqlScan(ctx context.Context, root *ProjectQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(pgb.fns))
-	for _, fn := range pgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*pgb.flds)+len(pgb.fns))
-		for _, f := range *pgb.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*pgb.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := pgb.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// ProjectSelect is the builder for selecting fields of Project entities.
-type ProjectSelect struct {
-	*ProjectQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (ps *ProjectSelect) Aggregate(fns ...AggregateFunc) *ProjectSelect {
-	ps.fns = append(ps.fns, fns...)
-	return ps
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (ps *ProjectSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, ps.ctx, "Select")
-	if err := ps.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*ProjectQuery, *ProjectSelect](ctx, ps.ProjectQuery, ps, ps.inters, v)
-}
-
-func (ps *ProjectSelect) sqlScan(ctx context.Context, root *ProjectQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(ps.fns))
-	for _, fn := range ps.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*ps.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := ps.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
diff --git a/backend/database/ent/project_update.go b/backend/database/ent/project_update.go
deleted file mode 100644
index 409aff9..0000000
--- a/backend/database/ent/project_update.go
+++ /dev/null
@@ -1,318 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// ProjectUpdate is the builder for updating Project entities.
-type ProjectUpdate struct {
-	config
-	hooks    []Hook
-	mutation *ProjectMutation
-}
-
-// Where appends a list predicates to the ProjectUpdate builder.
-func (pu *ProjectUpdate) Where(ps ...predicate.Project) *ProjectUpdate {
-	pu.mutation.Where(ps...)
-	return pu
-}
-
-// SetName sets the "name" field.
-func (pu *ProjectUpdate) SetName(s string) *ProjectUpdate {
-	pu.mutation.SetName(s)
-	return pu
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (pu *ProjectUpdate) SetNillableName(s *string) *ProjectUpdate {
-	if s != nil {
-		pu.SetName(*s)
-	}
-	return pu
-}
-
-// SetTeamID sets the "team" edge to the Team entity by ID.
-func (pu *ProjectUpdate) SetTeamID(id int) *ProjectUpdate {
-	pu.mutation.SetTeamID(id)
-	return pu
-}
-
-// SetNillableTeamID sets the "team" edge to the Team entity by ID if the given value is not nil.
-func (pu *ProjectUpdate) SetNillableTeamID(id *int) *ProjectUpdate {
-	if id != nil {
-		pu = pu.SetTeamID(*id)
-	}
-	return pu
-}
-
-// SetTeam sets the "team" edge to the Team entity.
-func (pu *ProjectUpdate) SetTeam(t *Team) *ProjectUpdate {
-	return pu.SetTeamID(t.ID)
-}
-
-// Mutation returns the ProjectMutation object of the builder.
-func (pu *ProjectUpdate) Mutation() *ProjectMutation {
-	return pu.mutation
-}
-
-// ClearTeam clears the "team" edge to the Team entity.
-func (pu *ProjectUpdate) ClearTeam() *ProjectUpdate {
-	pu.mutation.ClearTeam()
-	return pu
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (pu *ProjectUpdate) Save(ctx context.Context) (int, error) {
-	return withHooks(ctx, pu.sqlSave, pu.mutation, pu.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (pu *ProjectUpdate) SaveX(ctx context.Context) int {
-	affected, err := pu.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (pu *ProjectUpdate) Exec(ctx context.Context) error {
-	_, err := pu.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (pu *ProjectUpdate) ExecX(ctx context.Context) {
-	if err := pu.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-func (pu *ProjectUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := sqlgraph.NewUpdateSpec(project.Table, project.Columns, sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt))
-	if ps := pu.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := pu.mutation.Name(); ok {
-		_spec.SetField(project.FieldName, field.TypeString, value)
-	}
-	if pu.mutation.TeamCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   project.TeamTable,
-			Columns: []string{project.TeamColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := pu.mutation.TeamIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   project.TeamTable,
-			Columns: []string{project.TeamColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if n, err = sqlgraph.UpdateNodes(ctx, pu.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{project.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	pu.mutation.done = true
-	return n, nil
-}
-
-// ProjectUpdateOne is the builder for updating a single Project entity.
-type ProjectUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *ProjectMutation
-}
-
-// SetName sets the "name" field.
-func (puo *ProjectUpdateOne) SetName(s string) *ProjectUpdateOne {
-	puo.mutation.SetName(s)
-	return puo
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (puo *ProjectUpdateOne) SetNillableName(s *string) *ProjectUpdateOne {
-	if s != nil {
-		puo.SetName(*s)
-	}
-	return puo
-}
-
-// SetTeamID sets the "team" edge to the Team entity by ID.
-func (puo *ProjectUpdateOne) SetTeamID(id int) *ProjectUpdateOne {
-	puo.mutation.SetTeamID(id)
-	return puo
-}
-
-// SetNillableTeamID sets the "team" edge to the Team entity by ID if the given value is not nil.
-func (puo *ProjectUpdateOne) SetNillableTeamID(id *int) *ProjectUpdateOne {
-	if id != nil {
-		puo = puo.SetTeamID(*id)
-	}
-	return puo
-}
-
-// SetTeam sets the "team" edge to the Team entity.
-func (puo *ProjectUpdateOne) SetTeam(t *Team) *ProjectUpdateOne {
-	return puo.SetTeamID(t.ID)
-}
-
-// Mutation returns the ProjectMutation object of the builder.
-func (puo *ProjectUpdateOne) Mutation() *ProjectMutation {
-	return puo.mutation
-}
-
-// ClearTeam clears the "team" edge to the Team entity.
-func (puo *ProjectUpdateOne) ClearTeam() *ProjectUpdateOne {
-	puo.mutation.ClearTeam()
-	return puo
-}
-
-// Where appends a list predicates to the ProjectUpdate builder.
-func (puo *ProjectUpdateOne) Where(ps ...predicate.Project) *ProjectUpdateOne {
-	puo.mutation.Where(ps...)
-	return puo
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (puo *ProjectUpdateOne) Select(field string, fields ...string) *ProjectUpdateOne {
-	puo.fields = append([]string{field}, fields...)
-	return puo
-}
-
-// Save executes the query and returns the updated Project entity.
-func (puo *ProjectUpdateOne) Save(ctx context.Context) (*Project, error) {
-	return withHooks(ctx, puo.sqlSave, puo.mutation, puo.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (puo *ProjectUpdateOne) SaveX(ctx context.Context) *Project {
-	node, err := puo.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (puo *ProjectUpdateOne) Exec(ctx context.Context) error {
-	_, err := puo.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (puo *ProjectUpdateOne) ExecX(ctx context.Context) {
-	if err := puo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-func (puo *ProjectUpdateOne) sqlSave(ctx context.Context) (_node *Project, err error) {
-	_spec := sqlgraph.NewUpdateSpec(project.Table, project.Columns, sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt))
-	id, ok := puo.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Project.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := puo.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, project.FieldID)
-		for _, f := range fields {
-			if !project.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != project.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := puo.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := puo.mutation.Name(); ok {
-		_spec.SetField(project.FieldName, field.TypeString, value)
-	}
-	if puo.mutation.TeamCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   project.TeamTable,
-			Columns: []string{project.TeamColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := puo.mutation.TeamIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
-			Inverse: true,
-			Table:   project.TeamTable,
-			Columns: []string{project.TeamColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &Project{config: puo.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, puo.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{project.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	puo.mutation.done = true
-	return _node, nil
-}
diff --git a/backend/database/ent/runtime.go b/backend/database/ent/runtime.go
deleted file mode 100644
index 85fddb7..0000000
--- a/backend/database/ent/runtime.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"portfolio/backend/database/ent/schema"
-	"portfolio/backend/database/ent/user"
-)
-
-// The init function reads all schema descriptors with runtime code
-// (default values, validators, hooks and policies) and stitches it
-// to their package variables.
-func init() {
-	userFields := schema.User{}.Fields()
-	_ = userFields
-	// userDescName is the schema descriptor for name field.
-	userDescName := userFields[0].Descriptor()
-	// user.DefaultName holds the default value on creation for the name field.
-	user.DefaultName = userDescName.Default.(string)
-}
diff --git a/backend/database/ent/runtime/runtime.go b/backend/database/ent/runtime/runtime.go
deleted file mode 100644
index 2faaba5..0000000
--- a/backend/database/ent/runtime/runtime.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package runtime
-
-// The schema-stitching logic is generated in portfolio/backend/database/ent/runtime.go
-
-const (
-	Version = "v0.13.0"                                         // Version of ent codegen.
-	Sum     = "h1:DclxWczaCpyiKn6ZWVcJjq1zIKtJ11iNKy+08lNYsJE=" // Sum of ent codegen.
-)
diff --git a/backend/database/ent/team.go b/backend/database/ent/team.go
deleted file mode 100644
index 9e55f01..0000000
--- a/backend/database/ent/team.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"portfolio/backend/database/ent/team"
-	"strings"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-)
-
-// Team is the model entity for the Team schema.
-type Team struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int `json:"id,omitempty"`
-	// Name holds the value of the "name" field.
-	Name string `json:"name,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the TeamQuery when eager-loading is set.
-	Edges        TeamEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// TeamEdges holds the relations/edges for other nodes in the graph.
-type TeamEdges struct {
-	// Project holds the value of the project edge.
-	Project []*Project `json:"project,omitempty"`
-	// Users holds the value of the users edge.
-	Users []*User `json:"users,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [2]bool
-}
-
-// ProjectOrErr returns the Project value or an error if the edge
-// was not loaded in eager-loading.
-func (e TeamEdges) ProjectOrErr() ([]*Project, error) {
-	if e.loadedTypes[0] {
-		return e.Project, nil
-	}
-	return nil, &NotLoadedError{edge: "project"}
-}
-
-// UsersOrErr returns the Users value or an error if the edge
-// was not loaded in eager-loading.
-func (e TeamEdges) UsersOrErr() ([]*User, error) {
-	if e.loadedTypes[1] {
-		return e.Users, nil
-	}
-	return nil, &NotLoadedError{edge: "users"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*Team) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case team.FieldID:
-			values[i] = new(sql.NullInt64)
-		case team.FieldName:
-			values[i] = new(sql.NullString)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the Team fields.
-func (t *Team) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case team.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			t.ID = int(value.Int64)
-		case team.FieldName:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field name", values[i])
-			} else if value.Valid {
-				t.Name = value.String
-			}
-		default:
-			t.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the Team.
-// This includes values selected through modifiers, order, etc.
-func (t *Team) Value(name string) (ent.Value, error) {
-	return t.selectValues.Get(name)
-}
-
-// QueryProject queries the "project" edge of the Team entity.
-func (t *Team) QueryProject() *ProjectQuery {
-	return NewTeamClient(t.config).QueryProject(t)
-}
-
-// QueryUsers queries the "users" edge of the Team entity.
-func (t *Team) QueryUsers() *UserQuery {
-	return NewTeamClient(t.config).QueryUsers(t)
-}
-
-// Update returns a builder for updating this Team.
-// Note that you need to call Team.Unwrap() before calling this method if this Team
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (t *Team) Update() *TeamUpdateOne {
-	return NewTeamClient(t.config).UpdateOne(t)
-}
-
-// Unwrap unwraps the Team entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (t *Team) Unwrap() *Team {
-	_tx, ok := t.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: Team is not a transactional entity")
-	}
-	t.config.driver = _tx.drv
-	return t
-}
-
-// String implements the fmt.Stringer.
-func (t *Team) String() string {
-	var builder strings.Builder
-	builder.WriteString("Team(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", t.ID))
-	builder.WriteString("name=")
-	builder.WriteString(t.Name)
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// Teams is a parsable slice of Team.
-type Teams []*Team
diff --git a/backend/database/ent/team/team.go b/backend/database/ent/team/team.go
deleted file mode 100644
index f5b112e..0000000
--- a/backend/database/ent/team/team.go
+++ /dev/null
@@ -1,112 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package team
-
-import (
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the team type in the database.
-	Label = "team"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldName holds the string denoting the name field in the database.
-	FieldName = "name"
-	// EdgeProject holds the string denoting the project edge name in mutations.
-	EdgeProject = "project"
-	// EdgeUsers holds the string denoting the users edge name in mutations.
-	EdgeUsers = "users"
-	// Table holds the table name of the team in the database.
-	Table = "teams"
-	// ProjectTable is the table that holds the project relation/edge.
-	ProjectTable = "projects"
-	// ProjectInverseTable is the table name for the Project entity.
-	// It exists in this package in order to avoid circular dependency with the "project" package.
-	ProjectInverseTable = "projects"
-	// ProjectColumn is the table column denoting the project relation/edge.
-	ProjectColumn = "team_project"
-	// UsersTable is the table that holds the users relation/edge. The primary key declared below.
-	UsersTable = "user_teams"
-	// UsersInverseTable is the table name for the User entity.
-	// It exists in this package in order to avoid circular dependency with the "user" package.
-	UsersInverseTable = "users"
-)
-
-// Columns holds all SQL columns for team fields.
-var Columns = []string{
-	FieldID,
-	FieldName,
-}
-
-var (
-	// UsersPrimaryKey and UsersColumn2 are the table columns denoting the
-	// primary key for the users relation (M2M).
-	UsersPrimaryKey = []string{"user_id", "team_id"}
-)
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-// OrderOption defines the ordering options for the Team queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByName orders the results by the name field.
-func ByName(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldName, opts...).ToFunc()
-}
-
-// ByProjectCount orders the results by project count.
-func ByProjectCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newProjectStep(), opts...)
-	}
-}
-
-// ByProject orders the results by project terms.
-func ByProject(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newProjectStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-
-// ByUsersCount orders the results by users count.
-func ByUsersCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newUsersStep(), opts...)
-	}
-}
-
-// ByUsers orders the results by users terms.
-func ByUsers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newUsersStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-func newProjectStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(ProjectInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, ProjectTable, ProjectColumn),
-	)
-}
-func newUsersStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(UsersInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2M, true, UsersTable, UsersPrimaryKey...),
-	)
-}
diff --git a/backend/database/ent/team/where.go b/backend/database/ent/team/where.go
deleted file mode 100644
index 5194934..0000000
--- a/backend/database/ent/team/where.go
+++ /dev/null
@@ -1,186 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package team
-
-import (
-	"portfolio/backend/database/ent/predicate"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int) predicate.Team {
-	return predicate.Team(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int) predicate.Team {
-	return predicate.Team(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int) predicate.Team {
-	return predicate.Team(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int) predicate.Team {
-	return predicate.Team(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int) predicate.Team {
-	return predicate.Team(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int) predicate.Team {
-	return predicate.Team(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int) predicate.Team {
-	return predicate.Team(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int) predicate.Team {
-	return predicate.Team(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int) predicate.Team {
-	return predicate.Team(sql.FieldLTE(FieldID, id))
-}
-
-// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
-func Name(v string) predicate.Team {
-	return predicate.Team(sql.FieldEQ(FieldName, v))
-}
-
-// NameEQ applies the EQ predicate on the "name" field.
-func NameEQ(v string) predicate.Team {
-	return predicate.Team(sql.FieldEQ(FieldName, v))
-}
-
-// NameNEQ applies the NEQ predicate on the "name" field.
-func NameNEQ(v string) predicate.Team {
-	return predicate.Team(sql.FieldNEQ(FieldName, v))
-}
-
-// NameIn applies the In predicate on the "name" field.
-func NameIn(vs ...string) predicate.Team {
-	return predicate.Team(sql.FieldIn(FieldName, vs...))
-}
-
-// NameNotIn applies the NotIn predicate on the "name" field.
-func NameNotIn(vs ...string) predicate.Team {
-	return predicate.Team(sql.FieldNotIn(FieldName, vs...))
-}
-
-// NameGT applies the GT predicate on the "name" field.
-func NameGT(v string) predicate.Team {
-	return predicate.Team(sql.FieldGT(FieldName, v))
-}
-
-// NameGTE applies the GTE predicate on the "name" field.
-func NameGTE(v string) predicate.Team {
-	return predicate.Team(sql.FieldGTE(FieldName, v))
-}
-
-// NameLT applies the LT predicate on the "name" field.
-func NameLT(v string) predicate.Team {
-	return predicate.Team(sql.FieldLT(FieldName, v))
-}
-
-// NameLTE applies the LTE predicate on the "name" field.
-func NameLTE(v string) predicate.Team {
-	return predicate.Team(sql.FieldLTE(FieldName, v))
-}
-
-// NameContains applies the Contains predicate on the "name" field.
-func NameContains(v string) predicate.Team {
-	return predicate.Team(sql.FieldContains(FieldName, v))
-}
-
-// NameHasPrefix applies the HasPrefix predicate on the "name" field.
-func NameHasPrefix(v string) predicate.Team {
-	return predicate.Team(sql.FieldHasPrefix(FieldName, v))
-}
-
-// NameHasSuffix applies the HasSuffix predicate on the "name" field.
-func NameHasSuffix(v string) predicate.Team {
-	return predicate.Team(sql.FieldHasSuffix(FieldName, v))
-}
-
-// NameEqualFold applies the EqualFold predicate on the "name" field.
-func NameEqualFold(v string) predicate.Team {
-	return predicate.Team(sql.FieldEqualFold(FieldName, v))
-}
-
-// NameContainsFold applies the ContainsFold predicate on the "name" field.
-func NameContainsFold(v string) predicate.Team {
-	return predicate.Team(sql.FieldContainsFold(FieldName, v))
-}
-
-// HasProject applies the HasEdge predicate on the "project" edge.
-func HasProject() predicate.Team {
-	return predicate.Team(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, ProjectTable, ProjectColumn),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasProjectWith applies the HasEdge predicate on the "project" edge with a given conditions (other predicates).
-func HasProjectWith(preds ...predicate.Project) predicate.Team {
-	return predicate.Team(func(s *sql.Selector) {
-		step := newProjectStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// HasUsers applies the HasEdge predicate on the "users" edge.
-func HasUsers() predicate.Team {
-	return predicate.Team(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2M, true, UsersTable, UsersPrimaryKey...),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasUsersWith applies the HasEdge predicate on the "users" edge with a given conditions (other predicates).
-func HasUsersWith(preds ...predicate.User) predicate.Team {
-	return predicate.Team(func(s *sql.Selector) {
-		step := newUsersStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.Team) predicate.Team {
-	return predicate.Team(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.Team) predicate.Team {
-	return predicate.Team(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.Team) predicate.Team {
-	return predicate.Team(sql.NotPredicates(p))
-}
diff --git a/backend/database/ent/team_create.go b/backend/database/ent/team_create.go
deleted file mode 100644
index 8f94ebc..0000000
--- a/backend/database/ent/team_create.go
+++ /dev/null
@@ -1,247 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// TeamCreate is the builder for creating a Team entity.
-type TeamCreate struct {
-	config
-	mutation *TeamMutation
-	hooks    []Hook
-}
-
-// SetName sets the "name" field.
-func (tc *TeamCreate) SetName(s string) *TeamCreate {
-	tc.mutation.SetName(s)
-	return tc
-}
-
-// AddProjectIDs adds the "project" edge to the Project entity by IDs.
-func (tc *TeamCreate) AddProjectIDs(ids ...int) *TeamCreate {
-	tc.mutation.AddProjectIDs(ids...)
-	return tc
-}
-
-// AddProject adds the "project" edges to the Project entity.
-func (tc *TeamCreate) AddProject(p ...*Project) *TeamCreate {
-	ids := make([]int, len(p))
-	for i := range p {
-		ids[i] = p[i].ID
-	}
-	return tc.AddProjectIDs(ids...)
-}
-
-// AddUserIDs adds the "users" edge to the User entity by IDs.
-func (tc *TeamCreate) AddUserIDs(ids ...int) *TeamCreate {
-	tc.mutation.AddUserIDs(ids...)
-	return tc
-}
-
-// AddUsers adds the "users" edges to the User entity.
-func (tc *TeamCreate) AddUsers(u ...*User) *TeamCreate {
-	ids := make([]int, len(u))
-	for i := range u {
-		ids[i] = u[i].ID
-	}
-	return tc.AddUserIDs(ids...)
-}
-
-// Mutation returns the TeamMutation object of the builder.
-func (tc *TeamCreate) Mutation() *TeamMutation {
-	return tc.mutation
-}
-
-// Save creates the Team in the database.
-func (tc *TeamCreate) Save(ctx context.Context) (*Team, error) {
-	return withHooks(ctx, tc.sqlSave, tc.mutation, tc.hooks)
-}
-
-// SaveX calls Save and panics if Save returns an error.
-func (tc *TeamCreate) SaveX(ctx context.Context) *Team {
-	v, err := tc.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (tc *TeamCreate) Exec(ctx context.Context) error {
-	_, err := tc.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (tc *TeamCreate) ExecX(ctx context.Context) {
-	if err := tc.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (tc *TeamCreate) check() error {
-	if _, ok := tc.mutation.Name(); !ok {
-		return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "Team.name"`)}
-	}
-	return nil
-}
-
-func (tc *TeamCreate) sqlSave(ctx context.Context) (*Team, error) {
-	if err := tc.check(); err != nil {
-		return nil, err
-	}
-	_node, _spec := tc.createSpec()
-	if err := sqlgraph.CreateNode(ctx, tc.driver, _spec); err != nil {
-		if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	id := _spec.ID.Value.(int64)
-	_node.ID = int(id)
-	tc.mutation.id = &_node.ID
-	tc.mutation.done = true
-	return _node, nil
-}
-
-func (tc *TeamCreate) createSpec() (*Team, *sqlgraph.CreateSpec) {
-	var (
-		_node = &Team{config: tc.config}
-		_spec = sqlgraph.NewCreateSpec(team.Table, sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt))
-	)
-	if value, ok := tc.mutation.Name(); ok {
-		_spec.SetField(team.FieldName, field.TypeString, value)
-		_node.Name = value
-	}
-	if nodes := tc.mutation.ProjectIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	if nodes := tc.mutation.UsersIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	return _node, _spec
-}
-
-// TeamCreateBulk is the builder for creating many Team entities in bulk.
-type TeamCreateBulk struct {
-	config
-	err      error
-	builders []*TeamCreate
-}
-
-// Save creates the Team entities in the database.
-func (tcb *TeamCreateBulk) Save(ctx context.Context) ([]*Team, error) {
-	if tcb.err != nil {
-		return nil, tcb.err
-	}
-	specs := make([]*sqlgraph.CreateSpec, len(tcb.builders))
-	nodes := make([]*Team, len(tcb.builders))
-	mutators := make([]Mutator, len(tcb.builders))
-	for i := range tcb.builders {
-		func(i int, root context.Context) {
-			builder := tcb.builders[i]
-			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*TeamMutation)
-				if !ok {
-					return nil, fmt.Errorf("unexpected mutation type %T", m)
-				}
-				if err := builder.check(); err != nil {
-					return nil, err
-				}
-				builder.mutation = mutation
-				var err error
-				nodes[i], specs[i] = builder.createSpec()
-				if i < len(mutators)-1 {
-					_, err = mutators[i+1].Mutate(root, tcb.builders[i+1].mutation)
-				} else {
-					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
-					// Invoke the actual operation on the latest mutation in the chain.
-					if err = sqlgraph.BatchCreate(ctx, tcb.driver, spec); err != nil {
-						if sqlgraph.IsConstraintError(err) {
-							err = &ConstraintError{msg: err.Error(), wrap: err}
-						}
-					}
-				}
-				if err != nil {
-					return nil, err
-				}
-				mutation.id = &nodes[i].ID
-				if specs[i].ID.Value != nil {
-					id := specs[i].ID.Value.(int64)
-					nodes[i].ID = int(id)
-				}
-				mutation.done = true
-				return nodes[i], nil
-			})
-			for i := len(builder.hooks) - 1; i >= 0; i-- {
-				mut = builder.hooks[i](mut)
-			}
-			mutators[i] = mut
-		}(i, ctx)
-	}
-	if len(mutators) > 0 {
-		if _, err := mutators[0].Mutate(ctx, tcb.builders[0].mutation); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (tcb *TeamCreateBulk) SaveX(ctx context.Context) []*Team {
-	v, err := tcb.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (tcb *TeamCreateBulk) Exec(ctx context.Context) error {
-	_, err := tcb.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (tcb *TeamCreateBulk) ExecX(ctx context.Context) {
-	if err := tcb.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/backend/database/ent/team_delete.go b/backend/database/ent/team_delete.go
deleted file mode 100644
index 4ec3d90..0000000
--- a/backend/database/ent/team_delete.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/team"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// TeamDelete is the builder for deleting a Team entity.
-type TeamDelete struct {
-	config
-	hooks    []Hook
-	mutation *TeamMutation
-}
-
-// Where appends a list predicates to the TeamDelete builder.
-func (td *TeamDelete) Where(ps ...predicate.Team) *TeamDelete {
-	td.mutation.Where(ps...)
-	return td
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (td *TeamDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, td.sqlExec, td.mutation, td.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (td *TeamDelete) ExecX(ctx context.Context) int {
-	n, err := td.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (td *TeamDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(team.Table, sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt))
-	if ps := td.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, td.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	td.mutation.done = true
-	return affected, err
-}
-
-// TeamDeleteOne is the builder for deleting a single Team entity.
-type TeamDeleteOne struct {
-	td *TeamDelete
-}
-
-// Where appends a list predicates to the TeamDelete builder.
-func (tdo *TeamDeleteOne) Where(ps ...predicate.Team) *TeamDeleteOne {
-	tdo.td.mutation.Where(ps...)
-	return tdo
-}
-
-// Exec executes the deletion query.
-func (tdo *TeamDeleteOne) Exec(ctx context.Context) error {
-	n, err := tdo.td.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{team.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (tdo *TeamDeleteOne) ExecX(ctx context.Context) {
-	if err := tdo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/backend/database/ent/team_query.go b/backend/database/ent/team_query.go
deleted file mode 100644
index 48f277b..0000000
--- a/backend/database/ent/team_query.go
+++ /dev/null
@@ -1,711 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"database/sql/driver"
-	"fmt"
-	"math"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// TeamQuery is the builder for querying Team entities.
-type TeamQuery struct {
-	config
-	ctx         *QueryContext
-	order       []team.OrderOption
-	inters      []Interceptor
-	predicates  []predicate.Team
-	withProject *ProjectQuery
-	withUsers   *UserQuery
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the TeamQuery builder.
-func (tq *TeamQuery) Where(ps ...predicate.Team) *TeamQuery {
-	tq.predicates = append(tq.predicates, ps...)
-	return tq
-}
-
-// Limit the number of records to be returned by this query.
-func (tq *TeamQuery) Limit(limit int) *TeamQuery {
-	tq.ctx.Limit = &limit
-	return tq
-}
-
-// Offset to start from.
-func (tq *TeamQuery) Offset(offset int) *TeamQuery {
-	tq.ctx.Offset = &offset
-	return tq
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (tq *TeamQuery) Unique(unique bool) *TeamQuery {
-	tq.ctx.Unique = &unique
-	return tq
-}
-
-// Order specifies how the records should be ordered.
-func (tq *TeamQuery) Order(o ...team.OrderOption) *TeamQuery {
-	tq.order = append(tq.order, o...)
-	return tq
-}
-
-// QueryProject chains the current query on the "project" edge.
-func (tq *TeamQuery) QueryProject() *ProjectQuery {
-	query := (&ProjectClient{config: tq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := tq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := tq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(team.Table, team.FieldID, selector),
-			sqlgraph.To(project.Table, project.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, team.ProjectTable, team.ProjectColumn),
-		)
-		fromU = sqlgraph.SetNeighbors(tq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// QueryUsers chains the current query on the "users" edge.
-func (tq *TeamQuery) QueryUsers() *UserQuery {
-	query := (&UserClient{config: tq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := tq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := tq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(team.Table, team.FieldID, selector),
-			sqlgraph.To(user.Table, user.FieldID),
-			sqlgraph.Edge(sqlgraph.M2M, true, team.UsersTable, team.UsersPrimaryKey...),
-		)
-		fromU = sqlgraph.SetNeighbors(tq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first Team entity from the query.
-// Returns a *NotFoundError when no Team was found.
-func (tq *TeamQuery) First(ctx context.Context) (*Team, error) {
-	nodes, err := tq.Limit(1).All(setContextOp(ctx, tq.ctx, "First"))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{team.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (tq *TeamQuery) FirstX(ctx context.Context) *Team {
-	node, err := tq.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first Team ID from the query.
-// Returns a *NotFoundError when no Team ID was found.
-func (tq *TeamQuery) FirstID(ctx context.Context) (id int, err error) {
-	var ids []int
-	if ids, err = tq.Limit(1).IDs(setContextOp(ctx, tq.ctx, "FirstID")); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{team.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (tq *TeamQuery) FirstIDX(ctx context.Context) int {
-	id, err := tq.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single Team entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one Team entity is found.
-// Returns a *NotFoundError when no Team entities are found.
-func (tq *TeamQuery) Only(ctx context.Context) (*Team, error) {
-	nodes, err := tq.Limit(2).All(setContextOp(ctx, tq.ctx, "Only"))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{team.Label}
-	default:
-		return nil, &NotSingularError{team.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (tq *TeamQuery) OnlyX(ctx context.Context) *Team {
-	node, err := tq.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only Team ID in the query.
-// Returns a *NotSingularError when more than one Team ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (tq *TeamQuery) OnlyID(ctx context.Context) (id int, err error) {
-	var ids []int
-	if ids, err = tq.Limit(2).IDs(setContextOp(ctx, tq.ctx, "OnlyID")); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{team.Label}
-	default:
-		err = &NotSingularError{team.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (tq *TeamQuery) OnlyIDX(ctx context.Context) int {
-	id, err := tq.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of Teams.
-func (tq *TeamQuery) All(ctx context.Context) ([]*Team, error) {
-	ctx = setContextOp(ctx, tq.ctx, "All")
-	if err := tq.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*Team, *TeamQuery]()
-	return withInterceptors[[]*Team](ctx, tq, qr, tq.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (tq *TeamQuery) AllX(ctx context.Context) []*Team {
-	nodes, err := tq.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of Team IDs.
-func (tq *TeamQuery) IDs(ctx context.Context) (ids []int, err error) {
-	if tq.ctx.Unique == nil && tq.path != nil {
-		tq.Unique(true)
-	}
-	ctx = setContextOp(ctx, tq.ctx, "IDs")
-	if err = tq.Select(team.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (tq *TeamQuery) IDsX(ctx context.Context) []int {
-	ids, err := tq.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (tq *TeamQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, tq.ctx, "Count")
-	if err := tq.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, tq, querierCount[*TeamQuery](), tq.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (tq *TeamQuery) CountX(ctx context.Context) int {
-	count, err := tq.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (tq *TeamQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, tq.ctx, "Exist")
-	switch _, err := tq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (tq *TeamQuery) ExistX(ctx context.Context) bool {
-	exist, err := tq.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the TeamQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (tq *TeamQuery) Clone() *TeamQuery {
-	if tq == nil {
-		return nil
-	}
-	return &TeamQuery{
-		config:      tq.config,
-		ctx:         tq.ctx.Clone(),
-		order:       append([]team.OrderOption{}, tq.order...),
-		inters:      append([]Interceptor{}, tq.inters...),
-		predicates:  append([]predicate.Team{}, tq.predicates...),
-		withProject: tq.withProject.Clone(),
-		withUsers:   tq.withUsers.Clone(),
-		// clone intermediate query.
-		sql:  tq.sql.Clone(),
-		path: tq.path,
-	}
-}
-
-// WithProject tells the query-builder to eager-load the nodes that are connected to
-// the "project" edge. The optional arguments are used to configure the query builder of the edge.
-func (tq *TeamQuery) WithProject(opts ...func(*ProjectQuery)) *TeamQuery {
-	query := (&ProjectClient{config: tq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	tq.withProject = query
-	return tq
-}
-
-// WithUsers tells the query-builder to eager-load the nodes that are connected to
-// the "users" edge. The optional arguments are used to configure the query builder of the edge.
-func (tq *TeamQuery) WithUsers(opts ...func(*UserQuery)) *TeamQuery {
-	query := (&UserClient{config: tq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	tq.withUsers = query
-	return tq
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		Name string `json:"name,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.Team.Query().
-//		GroupBy(team.FieldName).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (tq *TeamQuery) GroupBy(field string, fields ...string) *TeamGroupBy {
-	tq.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &TeamGroupBy{build: tq}
-	grbuild.flds = &tq.ctx.Fields
-	grbuild.label = team.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		Name string `json:"name,omitempty"`
-//	}
-//
-//	client.Team.Query().
-//		Select(team.FieldName).
-//		Scan(ctx, &v)
-func (tq *TeamQuery) Select(fields ...string) *TeamSelect {
-	tq.ctx.Fields = append(tq.ctx.Fields, fields...)
-	sbuild := &TeamSelect{TeamQuery: tq}
-	sbuild.label = team.Label
-	sbuild.flds, sbuild.scan = &tq.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a TeamSelect configured with the given aggregations.
-func (tq *TeamQuery) Aggregate(fns ...AggregateFunc) *TeamSelect {
-	return tq.Select().Aggregate(fns...)
-}
-
-func (tq *TeamQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range tq.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, tq); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range tq.ctx.Fields {
-		if !team.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if tq.path != nil {
-		prev, err := tq.path(ctx)
-		if err != nil {
-			return err
-		}
-		tq.sql = prev
-	}
-	return nil
-}
-
-func (tq *TeamQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Team, error) {
-	var (
-		nodes       = []*Team{}
-		_spec       = tq.querySpec()
-		loadedTypes = [2]bool{
-			tq.withProject != nil,
-			tq.withUsers != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*Team).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &Team{config: tq.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, tq.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := tq.withProject; query != nil {
-		if err := tq.loadProject(ctx, query, nodes,
-			func(n *Team) { n.Edges.Project = []*Project{} },
-			func(n *Team, e *Project) { n.Edges.Project = append(n.Edges.Project, e) }); err != nil {
-			return nil, err
-		}
-	}
-	if query := tq.withUsers; query != nil {
-		if err := tq.loadUsers(ctx, query, nodes,
-			func(n *Team) { n.Edges.Users = []*User{} },
-			func(n *Team, e *User) { n.Edges.Users = append(n.Edges.Users, e) }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (tq *TeamQuery) loadProject(ctx context.Context, query *ProjectQuery, nodes []*Team, init func(*Team), assign func(*Team, *Project)) error {
-	fks := make([]driver.Value, 0, len(nodes))
-	nodeids := make(map[int]*Team)
-	for i := range nodes {
-		fks = append(fks, nodes[i].ID)
-		nodeids[nodes[i].ID] = nodes[i]
-		if init != nil {
-			init(nodes[i])
-		}
-	}
-	query.withFKs = true
-	query.Where(predicate.Project(func(s *sql.Selector) {
-		s.Where(sql.InValues(s.C(team.ProjectColumn), fks...))
-	}))
-	neighbors, err := query.All(ctx)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		fk := n.team_project
-		if fk == nil {
-			return fmt.Errorf(`foreign-key "team_project" is nil for node %v`, n.ID)
-		}
-		node, ok := nodeids[*fk]
-		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "team_project" returned %v for node %v`, *fk, n.ID)
-		}
-		assign(node, n)
-	}
-	return nil
-}
-func (tq *TeamQuery) loadUsers(ctx context.Context, query *UserQuery, nodes []*Team, init func(*Team), assign func(*Team, *User)) error {
-	edgeIDs := make([]driver.Value, len(nodes))
-	byID := make(map[int]*Team)
-	nids := make(map[int]map[*Team]struct{})
-	for i, node := range nodes {
-		edgeIDs[i] = node.ID
-		byID[node.ID] = node
-		if init != nil {
-			init(node)
-		}
-	}
-	query.Where(func(s *sql.Selector) {
-		joinT := sql.Table(team.UsersTable)
-		s.Join(joinT).On(s.C(user.FieldID), joinT.C(team.UsersPrimaryKey[0]))
-		s.Where(sql.InValues(joinT.C(team.UsersPrimaryKey[1]), edgeIDs...))
-		columns := s.SelectedColumns()
-		s.Select(joinT.C(team.UsersPrimaryKey[1]))
-		s.AppendSelect(columns...)
-		s.SetDistinct(false)
-	})
-	if err := query.prepareQuery(ctx); err != nil {
-		return err
-	}
-	qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
-			assign := spec.Assign
-			values := spec.ScanValues
-			spec.ScanValues = func(columns []string) ([]any, error) {
-				values, err := values(columns[1:])
-				if err != nil {
-					return nil, err
-				}
-				return append([]any{new(sql.NullInt64)}, values...), nil
-			}
-			spec.Assign = func(columns []string, values []any) error {
-				outValue := int(values[0].(*sql.NullInt64).Int64)
-				inValue := int(values[1].(*sql.NullInt64).Int64)
-				if nids[inValue] == nil {
-					nids[inValue] = map[*Team]struct{}{byID[outValue]: {}}
-					return assign(columns[1:], values[1:])
-				}
-				nids[inValue][byID[outValue]] = struct{}{}
-				return nil
-			}
-		})
-	})
-	neighbors, err := withInterceptors[[]*User](ctx, query, qr, query.inters)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected "users" node returned %v`, n.ID)
-		}
-		for kn := range nodes {
-			assign(kn, n)
-		}
-	}
-	return nil
-}
-
-func (tq *TeamQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := tq.querySpec()
-	_spec.Node.Columns = tq.ctx.Fields
-	if len(tq.ctx.Fields) > 0 {
-		_spec.Unique = tq.ctx.Unique != nil && *tq.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, tq.driver, _spec)
-}
-
-func (tq *TeamQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(team.Table, team.Columns, sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt))
-	_spec.From = tq.sql
-	if unique := tq.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if tq.path != nil {
-		_spec.Unique = true
-	}
-	if fields := tq.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, team.FieldID)
-		for i := range fields {
-			if fields[i] != team.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := tq.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := tq.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := tq.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := tq.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (tq *TeamQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(tq.driver.Dialect())
-	t1 := builder.Table(team.Table)
-	columns := tq.ctx.Fields
-	if len(columns) == 0 {
-		columns = team.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if tq.sql != nil {
-		selector = tq.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if tq.ctx.Unique != nil && *tq.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, p := range tq.predicates {
-		p(selector)
-	}
-	for _, p := range tq.order {
-		p(selector)
-	}
-	if offset := tq.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := tq.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// TeamGroupBy is the group-by builder for Team entities.
-type TeamGroupBy struct {
-	selector
-	build *TeamQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (tgb *TeamGroupBy) Aggregate(fns ...AggregateFunc) *TeamGroupBy {
-	tgb.fns = append(tgb.fns, fns...)
-	return tgb
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (tgb *TeamGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, tgb.build.ctx, "GroupBy")
-	if err := tgb.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*TeamQuery, *TeamGroupBy](ctx, tgb.build, tgb, tgb.build.inters, v)
-}
-
-func (tgb *TeamGroupBy) sqlScan(ctx context.Context, root *TeamQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(tgb.fns))
-	for _, fn := range tgb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*tgb.flds)+len(tgb.fns))
-		for _, f := range *tgb.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*tgb.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := tgb.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// TeamSelect is the builder for selecting fields of Team entities.
-type TeamSelect struct {
-	*TeamQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (ts *TeamSelect) Aggregate(fns ...AggregateFunc) *TeamSelect {
-	ts.fns = append(ts.fns, fns...)
-	return ts
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (ts *TeamSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, ts.ctx, "Select")
-	if err := ts.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*TeamQuery, *TeamSelect](ctx, ts.TeamQuery, ts, ts.inters, v)
-}
-
-func (ts *TeamSelect) sqlScan(ctx context.Context, root *TeamQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(ts.fns))
-	for _, fn := range ts.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*ts.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := ts.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
diff --git a/backend/database/ent/team_update.go b/backend/database/ent/team_update.go
deleted file mode 100644
index a34b677..0000000
--- a/backend/database/ent/team_update.go
+++ /dev/null
@@ -1,535 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/project"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// TeamUpdate is the builder for updating Team entities.
-type TeamUpdate struct {
-	config
-	hooks    []Hook
-	mutation *TeamMutation
-}
-
-// Where appends a list predicates to the TeamUpdate builder.
-func (tu *TeamUpdate) Where(ps ...predicate.Team) *TeamUpdate {
-	tu.mutation.Where(ps...)
-	return tu
-}
-
-// SetName sets the "name" field.
-func (tu *TeamUpdate) SetName(s string) *TeamUpdate {
-	tu.mutation.SetName(s)
-	return tu
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (tu *TeamUpdate) SetNillableName(s *string) *TeamUpdate {
-	if s != nil {
-		tu.SetName(*s)
-	}
-	return tu
-}
-
-// AddProjectIDs adds the "project" edge to the Project entity by IDs.
-func (tu *TeamUpdate) AddProjectIDs(ids ...int) *TeamUpdate {
-	tu.mutation.AddProjectIDs(ids...)
-	return tu
-}
-
-// AddProject adds the "project" edges to the Project entity.
-func (tu *TeamUpdate) AddProject(p ...*Project) *TeamUpdate {
-	ids := make([]int, len(p))
-	for i := range p {
-		ids[i] = p[i].ID
-	}
-	return tu.AddProjectIDs(ids...)
-}
-
-// AddUserIDs adds the "users" edge to the User entity by IDs.
-func (tu *TeamUpdate) AddUserIDs(ids ...int) *TeamUpdate {
-	tu.mutation.AddUserIDs(ids...)
-	return tu
-}
-
-// AddUsers adds the "users" edges to the User entity.
-func (tu *TeamUpdate) AddUsers(u ...*User) *TeamUpdate {
-	ids := make([]int, len(u))
-	for i := range u {
-		ids[i] = u[i].ID
-	}
-	return tu.AddUserIDs(ids...)
-}
-
-// Mutation returns the TeamMutation object of the builder.
-func (tu *TeamUpdate) Mutation() *TeamMutation {
-	return tu.mutation
-}
-
-// ClearProject clears all "project" edges to the Project entity.
-func (tu *TeamUpdate) ClearProject() *TeamUpdate {
-	tu.mutation.ClearProject()
-	return tu
-}
-
-// RemoveProjectIDs removes the "project" edge to Project entities by IDs.
-func (tu *TeamUpdate) RemoveProjectIDs(ids ...int) *TeamUpdate {
-	tu.mutation.RemoveProjectIDs(ids...)
-	return tu
-}
-
-// RemoveProject removes "project" edges to Project entities.
-func (tu *TeamUpdate) RemoveProject(p ...*Project) *TeamUpdate {
-	ids := make([]int, len(p))
-	for i := range p {
-		ids[i] = p[i].ID
-	}
-	return tu.RemoveProjectIDs(ids...)
-}
-
-// ClearUsers clears all "users" edges to the User entity.
-func (tu *TeamUpdate) ClearUsers() *TeamUpdate {
-	tu.mutation.ClearUsers()
-	return tu
-}
-
-// RemoveUserIDs removes the "users" edge to User entities by IDs.
-func (tu *TeamUpdate) RemoveUserIDs(ids ...int) *TeamUpdate {
-	tu.mutation.RemoveUserIDs(ids...)
-	return tu
-}
-
-// RemoveUsers removes "users" edges to User entities.
-func (tu *TeamUpdate) RemoveUsers(u ...*User) *TeamUpdate {
-	ids := make([]int, len(u))
-	for i := range u {
-		ids[i] = u[i].ID
-	}
-	return tu.RemoveUserIDs(ids...)
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (tu *TeamUpdate) Save(ctx context.Context) (int, error) {
-	return withHooks(ctx, tu.sqlSave, tu.mutation, tu.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (tu *TeamUpdate) SaveX(ctx context.Context) int {
-	affected, err := tu.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (tu *TeamUpdate) Exec(ctx context.Context) error {
-	_, err := tu.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (tu *TeamUpdate) ExecX(ctx context.Context) {
-	if err := tu.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-func (tu *TeamUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	_spec := sqlgraph.NewUpdateSpec(team.Table, team.Columns, sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt))
-	if ps := tu.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := tu.mutation.Name(); ok {
-		_spec.SetField(team.FieldName, field.TypeString, value)
-	}
-	if tu.mutation.ProjectCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tu.mutation.RemovedProjectIDs(); len(nodes) > 0 && !tu.mutation.ProjectCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tu.mutation.ProjectIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if tu.mutation.UsersCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tu.mutation.RemovedUsersIDs(); len(nodes) > 0 && !tu.mutation.UsersCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tu.mutation.UsersIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if n, err = sqlgraph.UpdateNodes(ctx, tu.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{team.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	tu.mutation.done = true
-	return n, nil
-}
-
-// TeamUpdateOne is the builder for updating a single Team entity.
-type TeamUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *TeamMutation
-}
-
-// SetName sets the "name" field.
-func (tuo *TeamUpdateOne) SetName(s string) *TeamUpdateOne {
-	tuo.mutation.SetName(s)
-	return tuo
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (tuo *TeamUpdateOne) SetNillableName(s *string) *TeamUpdateOne {
-	if s != nil {
-		tuo.SetName(*s)
-	}
-	return tuo
-}
-
-// AddProjectIDs adds the "project" edge to the Project entity by IDs.
-func (tuo *TeamUpdateOne) AddProjectIDs(ids ...int) *TeamUpdateOne {
-	tuo.mutation.AddProjectIDs(ids...)
-	return tuo
-}
-
-// AddProject adds the "project" edges to the Project entity.
-func (tuo *TeamUpdateOne) AddProject(p ...*Project) *TeamUpdateOne {
-	ids := make([]int, len(p))
-	for i := range p {
-		ids[i] = p[i].ID
-	}
-	return tuo.AddProjectIDs(ids...)
-}
-
-// AddUserIDs adds the "users" edge to the User entity by IDs.
-func (tuo *TeamUpdateOne) AddUserIDs(ids ...int) *TeamUpdateOne {
-	tuo.mutation.AddUserIDs(ids...)
-	return tuo
-}
-
-// AddUsers adds the "users" edges to the User entity.
-func (tuo *TeamUpdateOne) AddUsers(u ...*User) *TeamUpdateOne {
-	ids := make([]int, len(u))
-	for i := range u {
-		ids[i] = u[i].ID
-	}
-	return tuo.AddUserIDs(ids...)
-}
-
-// Mutation returns the TeamMutation object of the builder.
-func (tuo *TeamUpdateOne) Mutation() *TeamMutation {
-	return tuo.mutation
-}
-
-// ClearProject clears all "project" edges to the Project entity.
-func (tuo *TeamUpdateOne) ClearProject() *TeamUpdateOne {
-	tuo.mutation.ClearProject()
-	return tuo
-}
-
-// RemoveProjectIDs removes the "project" edge to Project entities by IDs.
-func (tuo *TeamUpdateOne) RemoveProjectIDs(ids ...int) *TeamUpdateOne {
-	tuo.mutation.RemoveProjectIDs(ids...)
-	return tuo
-}
-
-// RemoveProject removes "project" edges to Project entities.
-func (tuo *TeamUpdateOne) RemoveProject(p ...*Project) *TeamUpdateOne {
-	ids := make([]int, len(p))
-	for i := range p {
-		ids[i] = p[i].ID
-	}
-	return tuo.RemoveProjectIDs(ids...)
-}
-
-// ClearUsers clears all "users" edges to the User entity.
-func (tuo *TeamUpdateOne) ClearUsers() *TeamUpdateOne {
-	tuo.mutation.ClearUsers()
-	return tuo
-}
-
-// RemoveUserIDs removes the "users" edge to User entities by IDs.
-func (tuo *TeamUpdateOne) RemoveUserIDs(ids ...int) *TeamUpdateOne {
-	tuo.mutation.RemoveUserIDs(ids...)
-	return tuo
-}
-
-// RemoveUsers removes "users" edges to User entities.
-func (tuo *TeamUpdateOne) RemoveUsers(u ...*User) *TeamUpdateOne {
-	ids := make([]int, len(u))
-	for i := range u {
-		ids[i] = u[i].ID
-	}
-	return tuo.RemoveUserIDs(ids...)
-}
-
-// Where appends a list predicates to the TeamUpdate builder.
-func (tuo *TeamUpdateOne) Where(ps ...predicate.Team) *TeamUpdateOne {
-	tuo.mutation.Where(ps...)
-	return tuo
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (tuo *TeamUpdateOne) Select(field string, fields ...string) *TeamUpdateOne {
-	tuo.fields = append([]string{field}, fields...)
-	return tuo
-}
-
-// Save executes the query and returns the updated Team entity.
-func (tuo *TeamUpdateOne) Save(ctx context.Context) (*Team, error) {
-	return withHooks(ctx, tuo.sqlSave, tuo.mutation, tuo.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (tuo *TeamUpdateOne) SaveX(ctx context.Context) *Team {
-	node, err := tuo.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (tuo *TeamUpdateOne) Exec(ctx context.Context) error {
-	_, err := tuo.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (tuo *TeamUpdateOne) ExecX(ctx context.Context) {
-	if err := tuo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-func (tuo *TeamUpdateOne) sqlSave(ctx context.Context) (_node *Team, err error) {
-	_spec := sqlgraph.NewUpdateSpec(team.Table, team.Columns, sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt))
-	id, ok := tuo.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Team.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := tuo.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, team.FieldID)
-		for _, f := range fields {
-			if !team.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != team.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := tuo.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := tuo.mutation.Name(); ok {
-		_spec.SetField(team.FieldName, field.TypeString, value)
-	}
-	if tuo.mutation.ProjectCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tuo.mutation.RemovedProjectIDs(); len(nodes) > 0 && !tuo.mutation.ProjectCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tuo.mutation.ProjectIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
-			Inverse: false,
-			Table:   team.ProjectTable,
-			Columns: []string{team.ProjectColumn},
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(project.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if tuo.mutation.UsersCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tuo.mutation.RemovedUsersIDs(); len(nodes) > 0 && !tuo.mutation.UsersCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := tuo.mutation.UsersIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: true,
-			Table:   team.UsersTable,
-			Columns: team.UsersPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &Team{config: tuo.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, tuo.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{team.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	tuo.mutation.done = true
-	return _node, nil
-}
diff --git a/backend/database/ent/tx.go b/backend/database/ent/tx.go
deleted file mode 100644
index 39c9bb8..0000000
--- a/backend/database/ent/tx.go
+++ /dev/null
@@ -1,216 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"sync"
-
-	"entgo.io/ent/dialect"
-)
-
-// Tx is a transactional client that is created by calling Client.Tx().
-type Tx struct {
-	config
-	// Project is the client for interacting with the Project builders.
-	Project *ProjectClient
-	// Team is the client for interacting with the Team builders.
-	Team *TeamClient
-	// User is the client for interacting with the User builders.
-	User *UserClient
-
-	// lazily loaded.
-	client     *Client
-	clientOnce sync.Once
-	// ctx lives for the life of the transaction. It is
-	// the same context used by the underlying connection.
-	ctx context.Context
-}
-
-type (
-	// Committer is the interface that wraps the Commit method.
-	Committer interface {
-		Commit(context.Context, *Tx) error
-	}
-
-	// The CommitFunc type is an adapter to allow the use of ordinary
-	// function as a Committer. If f is a function with the appropriate
-	// signature, CommitFunc(f) is a Committer that calls f.
-	CommitFunc func(context.Context, *Tx) error
-
-	// CommitHook defines the "commit middleware". A function that gets a Committer
-	// and returns a Committer. For example:
-	//
-	//	hook := func(next ent.Committer) ent.Committer {
-	//		return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
-	//			// Do some stuff before.
-	//			if err := next.Commit(ctx, tx); err != nil {
-	//				return err
-	//			}
-	//			// Do some stuff after.
-	//			return nil
-	//		})
-	//	}
-	//
-	CommitHook func(Committer) Committer
-)
-
-// Commit calls f(ctx, m).
-func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error {
-	return f(ctx, tx)
-}
-
-// Commit commits the transaction.
-func (tx *Tx) Commit() error {
-	txDriver := tx.config.driver.(*txDriver)
-	var fn Committer = CommitFunc(func(context.Context, *Tx) error {
-		return txDriver.tx.Commit()
-	})
-	txDriver.mu.Lock()
-	hooks := append([]CommitHook(nil), txDriver.onCommit...)
-	txDriver.mu.Unlock()
-	for i := len(hooks) - 1; i >= 0; i-- {
-		fn = hooks[i](fn)
-	}
-	return fn.Commit(tx.ctx, tx)
-}
-
-// OnCommit adds a hook to call on commit.
-func (tx *Tx) OnCommit(f CommitHook) {
-	txDriver := tx.config.driver.(*txDriver)
-	txDriver.mu.Lock()
-	txDriver.onCommit = append(txDriver.onCommit, f)
-	txDriver.mu.Unlock()
-}
-
-type (
-	// Rollbacker is the interface that wraps the Rollback method.
-	Rollbacker interface {
-		Rollback(context.Context, *Tx) error
-	}
-
-	// The RollbackFunc type is an adapter to allow the use of ordinary
-	// function as a Rollbacker. If f is a function with the appropriate
-	// signature, RollbackFunc(f) is a Rollbacker that calls f.
-	RollbackFunc func(context.Context, *Tx) error
-
-	// RollbackHook defines the "rollback middleware". A function that gets a Rollbacker
-	// and returns a Rollbacker. For example:
-	//
-	//	hook := func(next ent.Rollbacker) ent.Rollbacker {
-	//		return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
-	//			// Do some stuff before.
-	//			if err := next.Rollback(ctx, tx); err != nil {
-	//				return err
-	//			}
-	//			// Do some stuff after.
-	//			return nil
-	//		})
-	//	}
-	//
-	RollbackHook func(Rollbacker) Rollbacker
-)
-
-// Rollback calls f(ctx, m).
-func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error {
-	return f(ctx, tx)
-}
-
-// Rollback rollbacks the transaction.
-func (tx *Tx) Rollback() error {
-	txDriver := tx.config.driver.(*txDriver)
-	var fn Rollbacker = RollbackFunc(func(context.Context, *Tx) error {
-		return txDriver.tx.Rollback()
-	})
-	txDriver.mu.Lock()
-	hooks := append([]RollbackHook(nil), txDriver.onRollback...)
-	txDriver.mu.Unlock()
-	for i := len(hooks) - 1; i >= 0; i-- {
-		fn = hooks[i](fn)
-	}
-	return fn.Rollback(tx.ctx, tx)
-}
-
-// OnRollback adds a hook to call on rollback.
-func (tx *Tx) OnRollback(f RollbackHook) {
-	txDriver := tx.config.driver.(*txDriver)
-	txDriver.mu.Lock()
-	txDriver.onRollback = append(txDriver.onRollback, f)
-	txDriver.mu.Unlock()
-}
-
-// Client returns a Client that binds to current transaction.
-func (tx *Tx) Client() *Client {
-	tx.clientOnce.Do(func() {
-		tx.client = &Client{config: tx.config}
-		tx.client.init()
-	})
-	return tx.client
-}
-
-func (tx *Tx) init() {
-	tx.Project = NewProjectClient(tx.config)
-	tx.Team = NewTeamClient(tx.config)
-	tx.User = NewUserClient(tx.config)
-}
-
-// txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation.
-// The idea is to support transactions without adding any extra code to the builders.
-// When a builder calls to driver.Tx(), it gets the same dialect.Tx instance.
-// Commit and Rollback are nop for the internal builders and the user must call one
-// of them in order to commit or rollback the transaction.
-//
-// If a closed transaction is embedded in one of the generated entities, and the entity
-// applies a query, for example: Project.QueryXXX(), the query will be executed
-// through the driver which created this transaction.
-//
-// Note that txDriver is not goroutine safe.
-type txDriver struct {
-	// the driver we started the transaction from.
-	drv dialect.Driver
-	// tx is the underlying transaction.
-	tx dialect.Tx
-	// completion hooks.
-	mu         sync.Mutex
-	onCommit   []CommitHook
-	onRollback []RollbackHook
-}
-
-// newTx creates a new transactional driver.
-func newTx(ctx context.Context, drv dialect.Driver) (*txDriver, error) {
-	tx, err := drv.Tx(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return &txDriver{tx: tx, drv: drv}, nil
-}
-
-// Tx returns the transaction wrapper (txDriver) to avoid Commit or Rollback calls
-// from the internal builders. Should be called only by the internal builders.
-func (tx *txDriver) Tx(context.Context) (dialect.Tx, error) { return tx, nil }
-
-// Dialect returns the dialect of the driver we started the transaction from.
-func (tx *txDriver) Dialect() string { return tx.drv.Dialect() }
-
-// Close is a nop close.
-func (*txDriver) Close() error { return nil }
-
-// Commit is a nop commit for the internal builders.
-// User must call `Tx.Commit` in order to commit the transaction.
-func (*txDriver) Commit() error { return nil }
-
-// Rollback is a nop rollback for the internal builders.
-// User must call `Tx.Rollback` in order to rollback the transaction.
-func (*txDriver) Rollback() error { return nil }
-
-// Exec calls tx.Exec.
-func (tx *txDriver) Exec(ctx context.Context, query string, args, v any) error {
-	return tx.tx.Exec(ctx, query, args, v)
-}
-
-// Query calls tx.Query.
-func (tx *txDriver) Query(ctx context.Context, query string, args, v any) error {
-	return tx.tx.Query(ctx, query, args, v)
-}
-
-var _ dialect.Driver = (*txDriver)(nil)
diff --git a/backend/database/ent/user.go b/backend/database/ent/user.go
deleted file mode 100644
index 6b1d779..0000000
--- a/backend/database/ent/user.go
+++ /dev/null
@@ -1,140 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"fmt"
-	"portfolio/backend/database/ent/user"
-	"strings"
-
-	"entgo.io/ent"
-	"entgo.io/ent/dialect/sql"
-)
-
-// User is the model entity for the User schema.
-type User struct {
-	config `json:"-"`
-	// ID of the ent.
-	ID int `json:"id,omitempty"`
-	// Name holds the value of the "name" field.
-	Name string `json:"name,omitempty"`
-	// Role holds the value of the "role" field.
-	Role user.Role `json:"role,omitempty"`
-	// Edges holds the relations/edges for other nodes in the graph.
-	// The values are being populated by the UserQuery when eager-loading is set.
-	Edges        UserEdges `json:"edges"`
-	selectValues sql.SelectValues
-}
-
-// UserEdges holds the relations/edges for other nodes in the graph.
-type UserEdges struct {
-	// Teams holds the value of the teams edge.
-	Teams []*Team `json:"teams,omitempty"`
-	// loadedTypes holds the information for reporting if a
-	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [1]bool
-}
-
-// TeamsOrErr returns the Teams value or an error if the edge
-// was not loaded in eager-loading.
-func (e UserEdges) TeamsOrErr() ([]*Team, error) {
-	if e.loadedTypes[0] {
-		return e.Teams, nil
-	}
-	return nil, &NotLoadedError{edge: "teams"}
-}
-
-// scanValues returns the types for scanning values from sql.Rows.
-func (*User) scanValues(columns []string) ([]any, error) {
-	values := make([]any, len(columns))
-	for i := range columns {
-		switch columns[i] {
-		case user.FieldID:
-			values[i] = new(sql.NullInt64)
-		case user.FieldName, user.FieldRole:
-			values[i] = new(sql.NullString)
-		default:
-			values[i] = new(sql.UnknownType)
-		}
-	}
-	return values, nil
-}
-
-// assignValues assigns the values that were returned from sql.Rows (after scanning)
-// to the User fields.
-func (u *User) assignValues(columns []string, values []any) error {
-	if m, n := len(values), len(columns); m < n {
-		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
-	}
-	for i := range columns {
-		switch columns[i] {
-		case user.FieldID:
-			value, ok := values[i].(*sql.NullInt64)
-			if !ok {
-				return fmt.Errorf("unexpected type %T for field id", value)
-			}
-			u.ID = int(value.Int64)
-		case user.FieldName:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field name", values[i])
-			} else if value.Valid {
-				u.Name = value.String
-			}
-		case user.FieldRole:
-			if value, ok := values[i].(*sql.NullString); !ok {
-				return fmt.Errorf("unexpected type %T for field role", values[i])
-			} else if value.Valid {
-				u.Role = user.Role(value.String)
-			}
-		default:
-			u.selectValues.Set(columns[i], values[i])
-		}
-	}
-	return nil
-}
-
-// Value returns the ent.Value that was dynamically selected and assigned to the User.
-// This includes values selected through modifiers, order, etc.
-func (u *User) Value(name string) (ent.Value, error) {
-	return u.selectValues.Get(name)
-}
-
-// QueryTeams queries the "teams" edge of the User entity.
-func (u *User) QueryTeams() *TeamQuery {
-	return NewUserClient(u.config).QueryTeams(u)
-}
-
-// Update returns a builder for updating this User.
-// Note that you need to call User.Unwrap() before calling this method if this User
-// was returned from a transaction, and the transaction was committed or rolled back.
-func (u *User) Update() *UserUpdateOne {
-	return NewUserClient(u.config).UpdateOne(u)
-}
-
-// Unwrap unwraps the User entity that was returned from a transaction after it was closed,
-// so that all future queries will be executed through the driver which created the transaction.
-func (u *User) Unwrap() *User {
-	_tx, ok := u.config.driver.(*txDriver)
-	if !ok {
-		panic("ent: User is not a transactional entity")
-	}
-	u.config.driver = _tx.drv
-	return u
-}
-
-// String implements the fmt.Stringer.
-func (u *User) String() string {
-	var builder strings.Builder
-	builder.WriteString("User(")
-	builder.WriteString(fmt.Sprintf("id=%v, ", u.ID))
-	builder.WriteString("name=")
-	builder.WriteString(u.Name)
-	builder.WriteString(", ")
-	builder.WriteString("role=")
-	builder.WriteString(fmt.Sprintf("%v", u.Role))
-	builder.WriteByte(')')
-	return builder.String()
-}
-
-// Users is a parsable slice of User.
-type Users []*User
diff --git a/backend/database/ent/user/user.go b/backend/database/ent/user/user.go
deleted file mode 100644
index 4499533..0000000
--- a/backend/database/ent/user/user.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package user
-
-import (
-	"fmt"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-const (
-	// Label holds the string label denoting the user type in the database.
-	Label = "user"
-	// FieldID holds the string denoting the id field in the database.
-	FieldID = "id"
-	// FieldName holds the string denoting the name field in the database.
-	FieldName = "name"
-	// FieldRole holds the string denoting the role field in the database.
-	FieldRole = "role"
-	// EdgeTeams holds the string denoting the teams edge name in mutations.
-	EdgeTeams = "teams"
-	// Table holds the table name of the user in the database.
-	Table = "users"
-	// TeamsTable is the table that holds the teams relation/edge. The primary key declared below.
-	TeamsTable = "user_teams"
-	// TeamsInverseTable is the table name for the Team entity.
-	// It exists in this package in order to avoid circular dependency with the "team" package.
-	TeamsInverseTable = "teams"
-)
-
-// Columns holds all SQL columns for user fields.
-var Columns = []string{
-	FieldID,
-	FieldName,
-	FieldRole,
-}
-
-var (
-	// TeamsPrimaryKey and TeamsColumn2 are the table columns denoting the
-	// primary key for the teams relation (M2M).
-	TeamsPrimaryKey = []string{"user_id", "team_id"}
-)
-
-// ValidColumn reports if the column name is valid (part of the table columns).
-func ValidColumn(column string) bool {
-	for i := range Columns {
-		if column == Columns[i] {
-			return true
-		}
-	}
-	return false
-}
-
-var (
-	// DefaultName holds the default value on creation for the "name" field.
-	DefaultName string
-)
-
-// Role defines the type for the "role" enum field.
-type Role string
-
-// Role values.
-const (
-	RoleAdmin   Role = "admin"
-	RoleUser    Role = "user"
-	RoleVisitor Role = "visitor"
-)
-
-func (r Role) String() string {
-	return string(r)
-}
-
-// RoleValidator is a validator for the "role" field enum values. It is called by the builders before save.
-func RoleValidator(r Role) error {
-	switch r {
-	case RoleAdmin, RoleUser, RoleVisitor:
-		return nil
-	default:
-		return fmt.Errorf("user: invalid enum value for role field: %q", r)
-	}
-}
-
-// OrderOption defines the ordering options for the User queries.
-type OrderOption func(*sql.Selector)
-
-// ByID orders the results by the id field.
-func ByID(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldID, opts...).ToFunc()
-}
-
-// ByName orders the results by the name field.
-func ByName(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldName, opts...).ToFunc()
-}
-
-// ByRole orders the results by the role field.
-func ByRole(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRole, opts...).ToFunc()
-}
-
-// ByTeamsCount orders the results by teams count.
-func ByTeamsCount(opts ...sql.OrderTermOption) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborsCount(s, newTeamsStep(), opts...)
-	}
-}
-
-// ByTeams orders the results by teams terms.
-func ByTeams(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
-	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newTeamsStep(), append([]sql.OrderTerm{term}, terms...)...)
-	}
-}
-func newTeamsStep() *sqlgraph.Step {
-	return sqlgraph.NewStep(
-		sqlgraph.From(Table, FieldID),
-		sqlgraph.To(TeamsInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2M, false, TeamsTable, TeamsPrimaryKey...),
-	)
-}
diff --git a/backend/database/ent/user/where.go b/backend/database/ent/user/where.go
deleted file mode 100644
index 84f265d..0000000
--- a/backend/database/ent/user/where.go
+++ /dev/null
@@ -1,183 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package user
-
-import (
-	"portfolio/backend/database/ent/predicate"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-)
-
-// ID filters vertices based on their ID field.
-func ID(id int) predicate.User {
-	return predicate.User(sql.FieldEQ(FieldID, id))
-}
-
-// IDEQ applies the EQ predicate on the ID field.
-func IDEQ(id int) predicate.User {
-	return predicate.User(sql.FieldEQ(FieldID, id))
-}
-
-// IDNEQ applies the NEQ predicate on the ID field.
-func IDNEQ(id int) predicate.User {
-	return predicate.User(sql.FieldNEQ(FieldID, id))
-}
-
-// IDIn applies the In predicate on the ID field.
-func IDIn(ids ...int) predicate.User {
-	return predicate.User(sql.FieldIn(FieldID, ids...))
-}
-
-// IDNotIn applies the NotIn predicate on the ID field.
-func IDNotIn(ids ...int) predicate.User {
-	return predicate.User(sql.FieldNotIn(FieldID, ids...))
-}
-
-// IDGT applies the GT predicate on the ID field.
-func IDGT(id int) predicate.User {
-	return predicate.User(sql.FieldGT(FieldID, id))
-}
-
-// IDGTE applies the GTE predicate on the ID field.
-func IDGTE(id int) predicate.User {
-	return predicate.User(sql.FieldGTE(FieldID, id))
-}
-
-// IDLT applies the LT predicate on the ID field.
-func IDLT(id int) predicate.User {
-	return predicate.User(sql.FieldLT(FieldID, id))
-}
-
-// IDLTE applies the LTE predicate on the ID field.
-func IDLTE(id int) predicate.User {
-	return predicate.User(sql.FieldLTE(FieldID, id))
-}
-
-// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
-func Name(v string) predicate.User {
-	return predicate.User(sql.FieldEQ(FieldName, v))
-}
-
-// NameEQ applies the EQ predicate on the "name" field.
-func NameEQ(v string) predicate.User {
-	return predicate.User(sql.FieldEQ(FieldName, v))
-}
-
-// NameNEQ applies the NEQ predicate on the "name" field.
-func NameNEQ(v string) predicate.User {
-	return predicate.User(sql.FieldNEQ(FieldName, v))
-}
-
-// NameIn applies the In predicate on the "name" field.
-func NameIn(vs ...string) predicate.User {
-	return predicate.User(sql.FieldIn(FieldName, vs...))
-}
-
-// NameNotIn applies the NotIn predicate on the "name" field.
-func NameNotIn(vs ...string) predicate.User {
-	return predicate.User(sql.FieldNotIn(FieldName, vs...))
-}
-
-// NameGT applies the GT predicate on the "name" field.
-func NameGT(v string) predicate.User {
-	return predicate.User(sql.FieldGT(FieldName, v))
-}
-
-// NameGTE applies the GTE predicate on the "name" field.
-func NameGTE(v string) predicate.User {
-	return predicate.User(sql.FieldGTE(FieldName, v))
-}
-
-// NameLT applies the LT predicate on the "name" field.
-func NameLT(v string) predicate.User {
-	return predicate.User(sql.FieldLT(FieldName, v))
-}
-
-// NameLTE applies the LTE predicate on the "name" field.
-func NameLTE(v string) predicate.User {
-	return predicate.User(sql.FieldLTE(FieldName, v))
-}
-
-// NameContains applies the Contains predicate on the "name" field.
-func NameContains(v string) predicate.User {
-	return predicate.User(sql.FieldContains(FieldName, v))
-}
-
-// NameHasPrefix applies the HasPrefix predicate on the "name" field.
-func NameHasPrefix(v string) predicate.User {
-	return predicate.User(sql.FieldHasPrefix(FieldName, v))
-}
-
-// NameHasSuffix applies the HasSuffix predicate on the "name" field.
-func NameHasSuffix(v string) predicate.User {
-	return predicate.User(sql.FieldHasSuffix(FieldName, v))
-}
-
-// NameEqualFold applies the EqualFold predicate on the "name" field.
-func NameEqualFold(v string) predicate.User {
-	return predicate.User(sql.FieldEqualFold(FieldName, v))
-}
-
-// NameContainsFold applies the ContainsFold predicate on the "name" field.
-func NameContainsFold(v string) predicate.User {
-	return predicate.User(sql.FieldContainsFold(FieldName, v))
-}
-
-// RoleEQ applies the EQ predicate on the "role" field.
-func RoleEQ(v Role) predicate.User {
-	return predicate.User(sql.FieldEQ(FieldRole, v))
-}
-
-// RoleNEQ applies the NEQ predicate on the "role" field.
-func RoleNEQ(v Role) predicate.User {
-	return predicate.User(sql.FieldNEQ(FieldRole, v))
-}
-
-// RoleIn applies the In predicate on the "role" field.
-func RoleIn(vs ...Role) predicate.User {
-	return predicate.User(sql.FieldIn(FieldRole, vs...))
-}
-
-// RoleNotIn applies the NotIn predicate on the "role" field.
-func RoleNotIn(vs ...Role) predicate.User {
-	return predicate.User(sql.FieldNotIn(FieldRole, vs...))
-}
-
-// HasTeams applies the HasEdge predicate on the "teams" edge.
-func HasTeams() predicate.User {
-	return predicate.User(func(s *sql.Selector) {
-		step := sqlgraph.NewStep(
-			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2M, false, TeamsTable, TeamsPrimaryKey...),
-		)
-		sqlgraph.HasNeighbors(s, step)
-	})
-}
-
-// HasTeamsWith applies the HasEdge predicate on the "teams" edge with a given conditions (other predicates).
-func HasTeamsWith(preds ...predicate.Team) predicate.User {
-	return predicate.User(func(s *sql.Selector) {
-		step := newTeamsStep()
-		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
-			for _, p := range preds {
-				p(s)
-			}
-		})
-	})
-}
-
-// And groups predicates with the AND operator between them.
-func And(predicates ...predicate.User) predicate.User {
-	return predicate.User(sql.AndPredicates(predicates...))
-}
-
-// Or groups predicates with the OR operator between them.
-func Or(predicates ...predicate.User) predicate.User {
-	return predicate.User(sql.OrPredicates(predicates...))
-}
-
-// Not applies the not operator on the given predicate.
-func Not(p predicate.User) predicate.User {
-	return predicate.User(sql.NotPredicates(p))
-}
diff --git a/backend/database/ent/user_create.go b/backend/database/ent/user_create.go
deleted file mode 100644
index 8325b6f..0000000
--- a/backend/database/ent/user_create.go
+++ /dev/null
@@ -1,251 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// UserCreate is the builder for creating a User entity.
-type UserCreate struct {
-	config
-	mutation *UserMutation
-	hooks    []Hook
-}
-
-// SetName sets the "name" field.
-func (uc *UserCreate) SetName(s string) *UserCreate {
-	uc.mutation.SetName(s)
-	return uc
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (uc *UserCreate) SetNillableName(s *string) *UserCreate {
-	if s != nil {
-		uc.SetName(*s)
-	}
-	return uc
-}
-
-// SetRole sets the "role" field.
-func (uc *UserCreate) SetRole(u user.Role) *UserCreate {
-	uc.mutation.SetRole(u)
-	return uc
-}
-
-// AddTeamIDs adds the "teams" edge to the Team entity by IDs.
-func (uc *UserCreate) AddTeamIDs(ids ...int) *UserCreate {
-	uc.mutation.AddTeamIDs(ids...)
-	return uc
-}
-
-// AddTeams adds the "teams" edges to the Team entity.
-func (uc *UserCreate) AddTeams(t ...*Team) *UserCreate {
-	ids := make([]int, len(t))
-	for i := range t {
-		ids[i] = t[i].ID
-	}
-	return uc.AddTeamIDs(ids...)
-}
-
-// Mutation returns the UserMutation object of the builder.
-func (uc *UserCreate) Mutation() *UserMutation {
-	return uc.mutation
-}
-
-// Save creates the User in the database.
-func (uc *UserCreate) Save(ctx context.Context) (*User, error) {
-	uc.defaults()
-	return withHooks(ctx, uc.sqlSave, uc.mutation, uc.hooks)
-}
-
-// SaveX calls Save and panics if Save returns an error.
-func (uc *UserCreate) SaveX(ctx context.Context) *User {
-	v, err := uc.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (uc *UserCreate) Exec(ctx context.Context) error {
-	_, err := uc.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (uc *UserCreate) ExecX(ctx context.Context) {
-	if err := uc.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// defaults sets the default values of the builder before save.
-func (uc *UserCreate) defaults() {
-	if _, ok := uc.mutation.Name(); !ok {
-		v := user.DefaultName
-		uc.mutation.SetName(v)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (uc *UserCreate) check() error {
-	if _, ok := uc.mutation.Name(); !ok {
-		return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "User.name"`)}
-	}
-	if _, ok := uc.mutation.Role(); !ok {
-		return &ValidationError{Name: "role", err: errors.New(`ent: missing required field "User.role"`)}
-	}
-	if v, ok := uc.mutation.Role(); ok {
-		if err := user.RoleValidator(v); err != nil {
-			return &ValidationError{Name: "role", err: fmt.Errorf(`ent: validator failed for field "User.role": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (uc *UserCreate) sqlSave(ctx context.Context) (*User, error) {
-	if err := uc.check(); err != nil {
-		return nil, err
-	}
-	_node, _spec := uc.createSpec()
-	if err := sqlgraph.CreateNode(ctx, uc.driver, _spec); err != nil {
-		if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	id := _spec.ID.Value.(int64)
-	_node.ID = int(id)
-	uc.mutation.id = &_node.ID
-	uc.mutation.done = true
-	return _node, nil
-}
-
-func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
-	var (
-		_node = &User{config: uc.config}
-		_spec = sqlgraph.NewCreateSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt))
-	)
-	if value, ok := uc.mutation.Name(); ok {
-		_spec.SetField(user.FieldName, field.TypeString, value)
-		_node.Name = value
-	}
-	if value, ok := uc.mutation.Role(); ok {
-		_spec.SetField(user.FieldRole, field.TypeEnum, value)
-		_node.Role = value
-	}
-	if nodes := uc.mutation.TeamsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges = append(_spec.Edges, edge)
-	}
-	return _node, _spec
-}
-
-// UserCreateBulk is the builder for creating many User entities in bulk.
-type UserCreateBulk struct {
-	config
-	err      error
-	builders []*UserCreate
-}
-
-// Save creates the User entities in the database.
-func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) {
-	if ucb.err != nil {
-		return nil, ucb.err
-	}
-	specs := make([]*sqlgraph.CreateSpec, len(ucb.builders))
-	nodes := make([]*User, len(ucb.builders))
-	mutators := make([]Mutator, len(ucb.builders))
-	for i := range ucb.builders {
-		func(i int, root context.Context) {
-			builder := ucb.builders[i]
-			builder.defaults()
-			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
-				mutation, ok := m.(*UserMutation)
-				if !ok {
-					return nil, fmt.Errorf("unexpected mutation type %T", m)
-				}
-				if err := builder.check(); err != nil {
-					return nil, err
-				}
-				builder.mutation = mutation
-				var err error
-				nodes[i], specs[i] = builder.createSpec()
-				if i < len(mutators)-1 {
-					_, err = mutators[i+1].Mutate(root, ucb.builders[i+1].mutation)
-				} else {
-					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
-					// Invoke the actual operation on the latest mutation in the chain.
-					if err = sqlgraph.BatchCreate(ctx, ucb.driver, spec); err != nil {
-						if sqlgraph.IsConstraintError(err) {
-							err = &ConstraintError{msg: err.Error(), wrap: err}
-						}
-					}
-				}
-				if err != nil {
-					return nil, err
-				}
-				mutation.id = &nodes[i].ID
-				if specs[i].ID.Value != nil {
-					id := specs[i].ID.Value.(int64)
-					nodes[i].ID = int(id)
-				}
-				mutation.done = true
-				return nodes[i], nil
-			})
-			for i := len(builder.hooks) - 1; i >= 0; i-- {
-				mut = builder.hooks[i](mut)
-			}
-			mutators[i] = mut
-		}(i, ctx)
-	}
-	if len(mutators) > 0 {
-		if _, err := mutators[0].Mutate(ctx, ucb.builders[0].mutation); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User {
-	v, err := ucb.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return v
-}
-
-// Exec executes the query.
-func (ucb *UserCreateBulk) Exec(ctx context.Context) error {
-	_, err := ucb.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (ucb *UserCreateBulk) ExecX(ctx context.Context) {
-	if err := ucb.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/backend/database/ent/user_delete.go b/backend/database/ent/user_delete.go
deleted file mode 100644
index dff98c9..0000000
--- a/backend/database/ent/user_delete.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// UserDelete is the builder for deleting a User entity.
-type UserDelete struct {
-	config
-	hooks    []Hook
-	mutation *UserMutation
-}
-
-// Where appends a list predicates to the UserDelete builder.
-func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete {
-	ud.mutation.Where(ps...)
-	return ud
-}
-
-// Exec executes the deletion query and returns how many vertices were deleted.
-func (ud *UserDelete) Exec(ctx context.Context) (int, error) {
-	return withHooks(ctx, ud.sqlExec, ud.mutation, ud.hooks)
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (ud *UserDelete) ExecX(ctx context.Context) int {
-	n, err := ud.Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return n
-}
-
-func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) {
-	_spec := sqlgraph.NewDeleteSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt))
-	if ps := ud.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	affected, err := sqlgraph.DeleteNodes(ctx, ud.driver, _spec)
-	if err != nil && sqlgraph.IsConstraintError(err) {
-		err = &ConstraintError{msg: err.Error(), wrap: err}
-	}
-	ud.mutation.done = true
-	return affected, err
-}
-
-// UserDeleteOne is the builder for deleting a single User entity.
-type UserDeleteOne struct {
-	ud *UserDelete
-}
-
-// Where appends a list predicates to the UserDelete builder.
-func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne {
-	udo.ud.mutation.Where(ps...)
-	return udo
-}
-
-// Exec executes the deletion query.
-func (udo *UserDeleteOne) Exec(ctx context.Context) error {
-	n, err := udo.ud.Exec(ctx)
-	switch {
-	case err != nil:
-		return err
-	case n == 0:
-		return &NotFoundError{user.Label}
-	default:
-		return nil
-	}
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (udo *UserDeleteOne) ExecX(ctx context.Context) {
-	if err := udo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
diff --git a/backend/database/ent/user_query.go b/backend/database/ent/user_query.go
deleted file mode 100644
index b55ee69..0000000
--- a/backend/database/ent/user_query.go
+++ /dev/null
@@ -1,636 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"database/sql/driver"
-	"fmt"
-	"math"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// UserQuery is the builder for querying User entities.
-type UserQuery struct {
-	config
-	ctx        *QueryContext
-	order      []user.OrderOption
-	inters     []Interceptor
-	predicates []predicate.User
-	withTeams  *TeamQuery
-	// intermediate query (i.e. traversal path).
-	sql  *sql.Selector
-	path func(context.Context) (*sql.Selector, error)
-}
-
-// Where adds a new predicate for the UserQuery builder.
-func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery {
-	uq.predicates = append(uq.predicates, ps...)
-	return uq
-}
-
-// Limit the number of records to be returned by this query.
-func (uq *UserQuery) Limit(limit int) *UserQuery {
-	uq.ctx.Limit = &limit
-	return uq
-}
-
-// Offset to start from.
-func (uq *UserQuery) Offset(offset int) *UserQuery {
-	uq.ctx.Offset = &offset
-	return uq
-}
-
-// Unique configures the query builder to filter duplicate records on query.
-// By default, unique is set to true, and can be disabled using this method.
-func (uq *UserQuery) Unique(unique bool) *UserQuery {
-	uq.ctx.Unique = &unique
-	return uq
-}
-
-// Order specifies how the records should be ordered.
-func (uq *UserQuery) Order(o ...user.OrderOption) *UserQuery {
-	uq.order = append(uq.order, o...)
-	return uq
-}
-
-// QueryTeams chains the current query on the "teams" edge.
-func (uq *UserQuery) QueryTeams() *TeamQuery {
-	query := (&TeamClient{config: uq.config}).Query()
-	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
-		if err := uq.prepareQuery(ctx); err != nil {
-			return nil, err
-		}
-		selector := uq.sqlQuery(ctx)
-		if err := selector.Err(); err != nil {
-			return nil, err
-		}
-		step := sqlgraph.NewStep(
-			sqlgraph.From(user.Table, user.FieldID, selector),
-			sqlgraph.To(team.Table, team.FieldID),
-			sqlgraph.Edge(sqlgraph.M2M, false, user.TeamsTable, user.TeamsPrimaryKey...),
-		)
-		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
-		return fromU, nil
-	}
-	return query
-}
-
-// First returns the first User entity from the query.
-// Returns a *NotFoundError when no User was found.
-func (uq *UserQuery) First(ctx context.Context) (*User, error) {
-	nodes, err := uq.Limit(1).All(setContextOp(ctx, uq.ctx, "First"))
-	if err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nil, &NotFoundError{user.Label}
-	}
-	return nodes[0], nil
-}
-
-// FirstX is like First, but panics if an error occurs.
-func (uq *UserQuery) FirstX(ctx context.Context) *User {
-	node, err := uq.First(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return node
-}
-
-// FirstID returns the first User ID from the query.
-// Returns a *NotFoundError when no User ID was found.
-func (uq *UserQuery) FirstID(ctx context.Context) (id int, err error) {
-	var ids []int
-	if ids, err = uq.Limit(1).IDs(setContextOp(ctx, uq.ctx, "FirstID")); err != nil {
-		return
-	}
-	if len(ids) == 0 {
-		err = &NotFoundError{user.Label}
-		return
-	}
-	return ids[0], nil
-}
-
-// FirstIDX is like FirstID, but panics if an error occurs.
-func (uq *UserQuery) FirstIDX(ctx context.Context) int {
-	id, err := uq.FirstID(ctx)
-	if err != nil && !IsNotFound(err) {
-		panic(err)
-	}
-	return id
-}
-
-// Only returns a single User entity found by the query, ensuring it only returns one.
-// Returns a *NotSingularError when more than one User entity is found.
-// Returns a *NotFoundError when no User entities are found.
-func (uq *UserQuery) Only(ctx context.Context) (*User, error) {
-	nodes, err := uq.Limit(2).All(setContextOp(ctx, uq.ctx, "Only"))
-	if err != nil {
-		return nil, err
-	}
-	switch len(nodes) {
-	case 1:
-		return nodes[0], nil
-	case 0:
-		return nil, &NotFoundError{user.Label}
-	default:
-		return nil, &NotSingularError{user.Label}
-	}
-}
-
-// OnlyX is like Only, but panics if an error occurs.
-func (uq *UserQuery) OnlyX(ctx context.Context) *User {
-	node, err := uq.Only(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// OnlyID is like Only, but returns the only User ID in the query.
-// Returns a *NotSingularError when more than one User ID is found.
-// Returns a *NotFoundError when no entities are found.
-func (uq *UserQuery) OnlyID(ctx context.Context) (id int, err error) {
-	var ids []int
-	if ids, err = uq.Limit(2).IDs(setContextOp(ctx, uq.ctx, "OnlyID")); err != nil {
-		return
-	}
-	switch len(ids) {
-	case 1:
-		id = ids[0]
-	case 0:
-		err = &NotFoundError{user.Label}
-	default:
-		err = &NotSingularError{user.Label}
-	}
-	return
-}
-
-// OnlyIDX is like OnlyID, but panics if an error occurs.
-func (uq *UserQuery) OnlyIDX(ctx context.Context) int {
-	id, err := uq.OnlyID(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return id
-}
-
-// All executes the query and returns a list of Users.
-func (uq *UserQuery) All(ctx context.Context) ([]*User, error) {
-	ctx = setContextOp(ctx, uq.ctx, "All")
-	if err := uq.prepareQuery(ctx); err != nil {
-		return nil, err
-	}
-	qr := querierAll[[]*User, *UserQuery]()
-	return withInterceptors[[]*User](ctx, uq, qr, uq.inters)
-}
-
-// AllX is like All, but panics if an error occurs.
-func (uq *UserQuery) AllX(ctx context.Context) []*User {
-	nodes, err := uq.All(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return nodes
-}
-
-// IDs executes the query and returns a list of User IDs.
-func (uq *UserQuery) IDs(ctx context.Context) (ids []int, err error) {
-	if uq.ctx.Unique == nil && uq.path != nil {
-		uq.Unique(true)
-	}
-	ctx = setContextOp(ctx, uq.ctx, "IDs")
-	if err = uq.Select(user.FieldID).Scan(ctx, &ids); err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-// IDsX is like IDs, but panics if an error occurs.
-func (uq *UserQuery) IDsX(ctx context.Context) []int {
-	ids, err := uq.IDs(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return ids
-}
-
-// Count returns the count of the given query.
-func (uq *UserQuery) Count(ctx context.Context) (int, error) {
-	ctx = setContextOp(ctx, uq.ctx, "Count")
-	if err := uq.prepareQuery(ctx); err != nil {
-		return 0, err
-	}
-	return withInterceptors[int](ctx, uq, querierCount[*UserQuery](), uq.inters)
-}
-
-// CountX is like Count, but panics if an error occurs.
-func (uq *UserQuery) CountX(ctx context.Context) int {
-	count, err := uq.Count(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return count
-}
-
-// Exist returns true if the query has elements in the graph.
-func (uq *UserQuery) Exist(ctx context.Context) (bool, error) {
-	ctx = setContextOp(ctx, uq.ctx, "Exist")
-	switch _, err := uq.FirstID(ctx); {
-	case IsNotFound(err):
-		return false, nil
-	case err != nil:
-		return false, fmt.Errorf("ent: check existence: %w", err)
-	default:
-		return true, nil
-	}
-}
-
-// ExistX is like Exist, but panics if an error occurs.
-func (uq *UserQuery) ExistX(ctx context.Context) bool {
-	exist, err := uq.Exist(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return exist
-}
-
-// Clone returns a duplicate of the UserQuery builder, including all associated steps. It can be
-// used to prepare common query builders and use them differently after the clone is made.
-func (uq *UserQuery) Clone() *UserQuery {
-	if uq == nil {
-		return nil
-	}
-	return &UserQuery{
-		config:     uq.config,
-		ctx:        uq.ctx.Clone(),
-		order:      append([]user.OrderOption{}, uq.order...),
-		inters:     append([]Interceptor{}, uq.inters...),
-		predicates: append([]predicate.User{}, uq.predicates...),
-		withTeams:  uq.withTeams.Clone(),
-		// clone intermediate query.
-		sql:  uq.sql.Clone(),
-		path: uq.path,
-	}
-}
-
-// WithTeams tells the query-builder to eager-load the nodes that are connected to
-// the "teams" edge. The optional arguments are used to configure the query builder of the edge.
-func (uq *UserQuery) WithTeams(opts ...func(*TeamQuery)) *UserQuery {
-	query := (&TeamClient{config: uq.config}).Query()
-	for _, opt := range opts {
-		opt(query)
-	}
-	uq.withTeams = query
-	return uq
-}
-
-// GroupBy is used to group vertices by one or more fields/columns.
-// It is often used with aggregate functions, like: count, max, mean, min, sum.
-//
-// Example:
-//
-//	var v []struct {
-//		Name string `json:"name,omitempty"`
-//		Count int `json:"count,omitempty"`
-//	}
-//
-//	client.User.Query().
-//		GroupBy(user.FieldName).
-//		Aggregate(ent.Count()).
-//		Scan(ctx, &v)
-func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
-	uq.ctx.Fields = append([]string{field}, fields...)
-	grbuild := &UserGroupBy{build: uq}
-	grbuild.flds = &uq.ctx.Fields
-	grbuild.label = user.Label
-	grbuild.scan = grbuild.Scan
-	return grbuild
-}
-
-// Select allows the selection one or more fields/columns for the given query,
-// instead of selecting all fields in the entity.
-//
-// Example:
-//
-//	var v []struct {
-//		Name string `json:"name,omitempty"`
-//	}
-//
-//	client.User.Query().
-//		Select(user.FieldName).
-//		Scan(ctx, &v)
-func (uq *UserQuery) Select(fields ...string) *UserSelect {
-	uq.ctx.Fields = append(uq.ctx.Fields, fields...)
-	sbuild := &UserSelect{UserQuery: uq}
-	sbuild.label = user.Label
-	sbuild.flds, sbuild.scan = &uq.ctx.Fields, sbuild.Scan
-	return sbuild
-}
-
-// Aggregate returns a UserSelect configured with the given aggregations.
-func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect {
-	return uq.Select().Aggregate(fns...)
-}
-
-func (uq *UserQuery) prepareQuery(ctx context.Context) error {
-	for _, inter := range uq.inters {
-		if inter == nil {
-			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
-		}
-		if trv, ok := inter.(Traverser); ok {
-			if err := trv.Traverse(ctx, uq); err != nil {
-				return err
-			}
-		}
-	}
-	for _, f := range uq.ctx.Fields {
-		if !user.ValidColumn(f) {
-			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-		}
-	}
-	if uq.path != nil {
-		prev, err := uq.path(ctx)
-		if err != nil {
-			return err
-		}
-		uq.sql = prev
-	}
-	return nil
-}
-
-func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, error) {
-	var (
-		nodes       = []*User{}
-		_spec       = uq.querySpec()
-		loadedTypes = [1]bool{
-			uq.withTeams != nil,
-		}
-	)
-	_spec.ScanValues = func(columns []string) ([]any, error) {
-		return (*User).scanValues(nil, columns)
-	}
-	_spec.Assign = func(columns []string, values []any) error {
-		node := &User{config: uq.config}
-		nodes = append(nodes, node)
-		node.Edges.loadedTypes = loadedTypes
-		return node.assignValues(columns, values)
-	}
-	for i := range hooks {
-		hooks[i](ctx, _spec)
-	}
-	if err := sqlgraph.QueryNodes(ctx, uq.driver, _spec); err != nil {
-		return nil, err
-	}
-	if len(nodes) == 0 {
-		return nodes, nil
-	}
-	if query := uq.withTeams; query != nil {
-		if err := uq.loadTeams(ctx, query, nodes,
-			func(n *User) { n.Edges.Teams = []*Team{} },
-			func(n *User, e *Team) { n.Edges.Teams = append(n.Edges.Teams, e) }); err != nil {
-			return nil, err
-		}
-	}
-	return nodes, nil
-}
-
-func (uq *UserQuery) loadTeams(ctx context.Context, query *TeamQuery, nodes []*User, init func(*User), assign func(*User, *Team)) error {
-	edgeIDs := make([]driver.Value, len(nodes))
-	byID := make(map[int]*User)
-	nids := make(map[int]map[*User]struct{})
-	for i, node := range nodes {
-		edgeIDs[i] = node.ID
-		byID[node.ID] = node
-		if init != nil {
-			init(node)
-		}
-	}
-	query.Where(func(s *sql.Selector) {
-		joinT := sql.Table(user.TeamsTable)
-		s.Join(joinT).On(s.C(team.FieldID), joinT.C(user.TeamsPrimaryKey[1]))
-		s.Where(sql.InValues(joinT.C(user.TeamsPrimaryKey[0]), edgeIDs...))
-		columns := s.SelectedColumns()
-		s.Select(joinT.C(user.TeamsPrimaryKey[0]))
-		s.AppendSelect(columns...)
-		s.SetDistinct(false)
-	})
-	if err := query.prepareQuery(ctx); err != nil {
-		return err
-	}
-	qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
-		return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
-			assign := spec.Assign
-			values := spec.ScanValues
-			spec.ScanValues = func(columns []string) ([]any, error) {
-				values, err := values(columns[1:])
-				if err != nil {
-					return nil, err
-				}
-				return append([]any{new(sql.NullInt64)}, values...), nil
-			}
-			spec.Assign = func(columns []string, values []any) error {
-				outValue := int(values[0].(*sql.NullInt64).Int64)
-				inValue := int(values[1].(*sql.NullInt64).Int64)
-				if nids[inValue] == nil {
-					nids[inValue] = map[*User]struct{}{byID[outValue]: {}}
-					return assign(columns[1:], values[1:])
-				}
-				nids[inValue][byID[outValue]] = struct{}{}
-				return nil
-			}
-		})
-	})
-	neighbors, err := withInterceptors[[]*Team](ctx, query, qr, query.inters)
-	if err != nil {
-		return err
-	}
-	for _, n := range neighbors {
-		nodes, ok := nids[n.ID]
-		if !ok {
-			return fmt.Errorf(`unexpected "teams" node returned %v`, n.ID)
-		}
-		for kn := range nodes {
-			assign(kn, n)
-		}
-	}
-	return nil
-}
-
-func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) {
-	_spec := uq.querySpec()
-	_spec.Node.Columns = uq.ctx.Fields
-	if len(uq.ctx.Fields) > 0 {
-		_spec.Unique = uq.ctx.Unique != nil && *uq.ctx.Unique
-	}
-	return sqlgraph.CountNodes(ctx, uq.driver, _spec)
-}
-
-func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec {
-	_spec := sqlgraph.NewQuerySpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt))
-	_spec.From = uq.sql
-	if unique := uq.ctx.Unique; unique != nil {
-		_spec.Unique = *unique
-	} else if uq.path != nil {
-		_spec.Unique = true
-	}
-	if fields := uq.ctx.Fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
-		for i := range fields {
-			if fields[i] != user.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
-			}
-		}
-	}
-	if ps := uq.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if limit := uq.ctx.Limit; limit != nil {
-		_spec.Limit = *limit
-	}
-	if offset := uq.ctx.Offset; offset != nil {
-		_spec.Offset = *offset
-	}
-	if ps := uq.order; len(ps) > 0 {
-		_spec.Order = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	return _spec
-}
-
-func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector {
-	builder := sql.Dialect(uq.driver.Dialect())
-	t1 := builder.Table(user.Table)
-	columns := uq.ctx.Fields
-	if len(columns) == 0 {
-		columns = user.Columns
-	}
-	selector := builder.Select(t1.Columns(columns...)...).From(t1)
-	if uq.sql != nil {
-		selector = uq.sql
-		selector.Select(selector.Columns(columns...)...)
-	}
-	if uq.ctx.Unique != nil && *uq.ctx.Unique {
-		selector.Distinct()
-	}
-	for _, p := range uq.predicates {
-		p(selector)
-	}
-	for _, p := range uq.order {
-		p(selector)
-	}
-	if offset := uq.ctx.Offset; offset != nil {
-		// limit is mandatory for offset clause. We start
-		// with default value, and override it below if needed.
-		selector.Offset(*offset).Limit(math.MaxInt32)
-	}
-	if limit := uq.ctx.Limit; limit != nil {
-		selector.Limit(*limit)
-	}
-	return selector
-}
-
-// UserGroupBy is the group-by builder for User entities.
-type UserGroupBy struct {
-	selector
-	build *UserQuery
-}
-
-// Aggregate adds the given aggregation functions to the group-by query.
-func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy {
-	ugb.fns = append(ugb.fns, fns...)
-	return ugb
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (ugb *UserGroupBy) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, ugb.build.ctx, "GroupBy")
-	if err := ugb.build.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*UserQuery, *UserGroupBy](ctx, ugb.build, ugb, ugb.build.inters, v)
-}
-
-func (ugb *UserGroupBy) sqlScan(ctx context.Context, root *UserQuery, v any) error {
-	selector := root.sqlQuery(ctx).Select()
-	aggregation := make([]string, 0, len(ugb.fns))
-	for _, fn := range ugb.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	if len(selector.SelectedColumns()) == 0 {
-		columns := make([]string, 0, len(*ugb.flds)+len(ugb.fns))
-		for _, f := range *ugb.flds {
-			columns = append(columns, selector.C(f))
-		}
-		columns = append(columns, aggregation...)
-		selector.Select(columns...)
-	}
-	selector.GroupBy(selector.Columns(*ugb.flds...)...)
-	if err := selector.Err(); err != nil {
-		return err
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := ugb.build.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
-
-// UserSelect is the builder for selecting fields of User entities.
-type UserSelect struct {
-	*UserQuery
-	selector
-}
-
-// Aggregate adds the given aggregation functions to the selector query.
-func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect {
-	us.fns = append(us.fns, fns...)
-	return us
-}
-
-// Scan applies the selector query and scans the result into the given value.
-func (us *UserSelect) Scan(ctx context.Context, v any) error {
-	ctx = setContextOp(ctx, us.ctx, "Select")
-	if err := us.prepareQuery(ctx); err != nil {
-		return err
-	}
-	return scanWithInterceptors[*UserQuery, *UserSelect](ctx, us.UserQuery, us, us.inters, v)
-}
-
-func (us *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error {
-	selector := root.sqlQuery(ctx)
-	aggregation := make([]string, 0, len(us.fns))
-	for _, fn := range us.fns {
-		aggregation = append(aggregation, fn(selector))
-	}
-	switch n := len(*us.selector.flds); {
-	case n == 0 && len(aggregation) > 0:
-		selector.Select(aggregation...)
-	case n != 0 && len(aggregation) > 0:
-		selector.AppendSelect(aggregation...)
-	}
-	rows := &sql.Rows{}
-	query, args := selector.Query()
-	if err := us.driver.Query(ctx, query, args, rows); err != nil {
-		return err
-	}
-	defer rows.Close()
-	return sql.ScanSlice(rows, v)
-}
diff --git a/backend/database/ent/user_update.go b/backend/database/ent/user_update.go
deleted file mode 100644
index aaaaf68..0000000
--- a/backend/database/ent/user_update.go
+++ /dev/null
@@ -1,432 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"portfolio/backend/database/ent/predicate"
-	"portfolio/backend/database/ent/team"
-	"portfolio/backend/database/ent/user"
-
-	"entgo.io/ent/dialect/sql"
-	"entgo.io/ent/dialect/sql/sqlgraph"
-	"entgo.io/ent/schema/field"
-)
-
-// UserUpdate is the builder for updating User entities.
-type UserUpdate struct {
-	config
-	hooks    []Hook
-	mutation *UserMutation
-}
-
-// Where appends a list predicates to the UserUpdate builder.
-func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
-	uu.mutation.Where(ps...)
-	return uu
-}
-
-// SetName sets the "name" field.
-func (uu *UserUpdate) SetName(s string) *UserUpdate {
-	uu.mutation.SetName(s)
-	return uu
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (uu *UserUpdate) SetNillableName(s *string) *UserUpdate {
-	if s != nil {
-		uu.SetName(*s)
-	}
-	return uu
-}
-
-// SetRole sets the "role" field.
-func (uu *UserUpdate) SetRole(u user.Role) *UserUpdate {
-	uu.mutation.SetRole(u)
-	return uu
-}
-
-// SetNillableRole sets the "role" field if the given value is not nil.
-func (uu *UserUpdate) SetNillableRole(u *user.Role) *UserUpdate {
-	if u != nil {
-		uu.SetRole(*u)
-	}
-	return uu
-}
-
-// AddTeamIDs adds the "teams" edge to the Team entity by IDs.
-func (uu *UserUpdate) AddTeamIDs(ids ...int) *UserUpdate {
-	uu.mutation.AddTeamIDs(ids...)
-	return uu
-}
-
-// AddTeams adds the "teams" edges to the Team entity.
-func (uu *UserUpdate) AddTeams(t ...*Team) *UserUpdate {
-	ids := make([]int, len(t))
-	for i := range t {
-		ids[i] = t[i].ID
-	}
-	return uu.AddTeamIDs(ids...)
-}
-
-// Mutation returns the UserMutation object of the builder.
-func (uu *UserUpdate) Mutation() *UserMutation {
-	return uu.mutation
-}
-
-// ClearTeams clears all "teams" edges to the Team entity.
-func (uu *UserUpdate) ClearTeams() *UserUpdate {
-	uu.mutation.ClearTeams()
-	return uu
-}
-
-// RemoveTeamIDs removes the "teams" edge to Team entities by IDs.
-func (uu *UserUpdate) RemoveTeamIDs(ids ...int) *UserUpdate {
-	uu.mutation.RemoveTeamIDs(ids...)
-	return uu
-}
-
-// RemoveTeams removes "teams" edges to Team entities.
-func (uu *UserUpdate) RemoveTeams(t ...*Team) *UserUpdate {
-	ids := make([]int, len(t))
-	for i := range t {
-		ids[i] = t[i].ID
-	}
-	return uu.RemoveTeamIDs(ids...)
-}
-
-// Save executes the query and returns the number of nodes affected by the update operation.
-func (uu *UserUpdate) Save(ctx context.Context) (int, error) {
-	return withHooks(ctx, uu.sqlSave, uu.mutation, uu.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (uu *UserUpdate) SaveX(ctx context.Context) int {
-	affected, err := uu.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return affected
-}
-
-// Exec executes the query.
-func (uu *UserUpdate) Exec(ctx context.Context) error {
-	_, err := uu.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (uu *UserUpdate) ExecX(ctx context.Context) {
-	if err := uu.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (uu *UserUpdate) check() error {
-	if v, ok := uu.mutation.Role(); ok {
-		if err := user.RoleValidator(v); err != nil {
-			return &ValidationError{Name: "role", err: fmt.Errorf(`ent: validator failed for field "User.role": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
-	if err := uu.check(); err != nil {
-		return n, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt))
-	if ps := uu.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := uu.mutation.Name(); ok {
-		_spec.SetField(user.FieldName, field.TypeString, value)
-	}
-	if value, ok := uu.mutation.Role(); ok {
-		_spec.SetField(user.FieldRole, field.TypeEnum, value)
-	}
-	if uu.mutation.TeamsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := uu.mutation.RemovedTeamsIDs(); len(nodes) > 0 && !uu.mutation.TeamsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := uu.mutation.TeamsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{user.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return 0, err
-	}
-	uu.mutation.done = true
-	return n, nil
-}
-
-// UserUpdateOne is the builder for updating a single User entity.
-type UserUpdateOne struct {
-	config
-	fields   []string
-	hooks    []Hook
-	mutation *UserMutation
-}
-
-// SetName sets the "name" field.
-func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne {
-	uuo.mutation.SetName(s)
-	return uuo
-}
-
-// SetNillableName sets the "name" field if the given value is not nil.
-func (uuo *UserUpdateOne) SetNillableName(s *string) *UserUpdateOne {
-	if s != nil {
-		uuo.SetName(*s)
-	}
-	return uuo
-}
-
-// SetRole sets the "role" field.
-func (uuo *UserUpdateOne) SetRole(u user.Role) *UserUpdateOne {
-	uuo.mutation.SetRole(u)
-	return uuo
-}
-
-// SetNillableRole sets the "role" field if the given value is not nil.
-func (uuo *UserUpdateOne) SetNillableRole(u *user.Role) *UserUpdateOne {
-	if u != nil {
-		uuo.SetRole(*u)
-	}
-	return uuo
-}
-
-// AddTeamIDs adds the "teams" edge to the Team entity by IDs.
-func (uuo *UserUpdateOne) AddTeamIDs(ids ...int) *UserUpdateOne {
-	uuo.mutation.AddTeamIDs(ids...)
-	return uuo
-}
-
-// AddTeams adds the "teams" edges to the Team entity.
-func (uuo *UserUpdateOne) AddTeams(t ...*Team) *UserUpdateOne {
-	ids := make([]int, len(t))
-	for i := range t {
-		ids[i] = t[i].ID
-	}
-	return uuo.AddTeamIDs(ids...)
-}
-
-// Mutation returns the UserMutation object of the builder.
-func (uuo *UserUpdateOne) Mutation() *UserMutation {
-	return uuo.mutation
-}
-
-// ClearTeams clears all "teams" edges to the Team entity.
-func (uuo *UserUpdateOne) ClearTeams() *UserUpdateOne {
-	uuo.mutation.ClearTeams()
-	return uuo
-}
-
-// RemoveTeamIDs removes the "teams" edge to Team entities by IDs.
-func (uuo *UserUpdateOne) RemoveTeamIDs(ids ...int) *UserUpdateOne {
-	uuo.mutation.RemoveTeamIDs(ids...)
-	return uuo
-}
-
-// RemoveTeams removes "teams" edges to Team entities.
-func (uuo *UserUpdateOne) RemoveTeams(t ...*Team) *UserUpdateOne {
-	ids := make([]int, len(t))
-	for i := range t {
-		ids[i] = t[i].ID
-	}
-	return uuo.RemoveTeamIDs(ids...)
-}
-
-// Where appends a list predicates to the UserUpdate builder.
-func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
-	uuo.mutation.Where(ps...)
-	return uuo
-}
-
-// Select allows selecting one or more fields (columns) of the returned entity.
-// The default is selecting all fields defined in the entity schema.
-func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne {
-	uuo.fields = append([]string{field}, fields...)
-	return uuo
-}
-
-// Save executes the query and returns the updated User entity.
-func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) {
-	return withHooks(ctx, uuo.sqlSave, uuo.mutation, uuo.hooks)
-}
-
-// SaveX is like Save, but panics if an error occurs.
-func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User {
-	node, err := uuo.Save(ctx)
-	if err != nil {
-		panic(err)
-	}
-	return node
-}
-
-// Exec executes the query on the entity.
-func (uuo *UserUpdateOne) Exec(ctx context.Context) error {
-	_, err := uuo.Save(ctx)
-	return err
-}
-
-// ExecX is like Exec, but panics if an error occurs.
-func (uuo *UserUpdateOne) ExecX(ctx context.Context) {
-	if err := uuo.Exec(ctx); err != nil {
-		panic(err)
-	}
-}
-
-// check runs all checks and user-defined validators on the builder.
-func (uuo *UserUpdateOne) check() error {
-	if v, ok := uuo.mutation.Role(); ok {
-		if err := user.RoleValidator(v); err != nil {
-			return &ValidationError{Name: "role", err: fmt.Errorf(`ent: validator failed for field "User.role": %w`, err)}
-		}
-	}
-	return nil
-}
-
-func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
-	if err := uuo.check(); err != nil {
-		return _node, err
-	}
-	_spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt))
-	id, ok := uuo.mutation.ID()
-	if !ok {
-		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "User.id" for update`)}
-	}
-	_spec.Node.ID.Value = id
-	if fields := uuo.fields; len(fields) > 0 {
-		_spec.Node.Columns = make([]string, 0, len(fields))
-		_spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
-		for _, f := range fields {
-			if !user.ValidColumn(f) {
-				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
-			}
-			if f != user.FieldID {
-				_spec.Node.Columns = append(_spec.Node.Columns, f)
-			}
-		}
-	}
-	if ps := uuo.mutation.predicates; len(ps) > 0 {
-		_spec.Predicate = func(selector *sql.Selector) {
-			for i := range ps {
-				ps[i](selector)
-			}
-		}
-	}
-	if value, ok := uuo.mutation.Name(); ok {
-		_spec.SetField(user.FieldName, field.TypeString, value)
-	}
-	if value, ok := uuo.mutation.Role(); ok {
-		_spec.SetField(user.FieldRole, field.TypeEnum, value)
-	}
-	if uuo.mutation.TeamsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := uuo.mutation.RemovedTeamsIDs(); len(nodes) > 0 && !uuo.mutation.TeamsCleared() {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
-	}
-	if nodes := uuo.mutation.TeamsIDs(); len(nodes) > 0 {
-		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2M,
-			Inverse: false,
-			Table:   user.TeamsTable,
-			Columns: user.TeamsPrimaryKey,
-			Bidi:    false,
-			Target: &sqlgraph.EdgeTarget{
-				IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeInt),
-			},
-		}
-		for _, k := range nodes {
-			edge.Target.Nodes = append(edge.Target.Nodes, k)
-		}
-		_spec.Edges.Add = append(_spec.Edges.Add, edge)
-	}
-	_node = &User{config: uuo.config}
-	_spec.Assign = _node.assignValues
-	_spec.ScanValues = _node.scanValues
-	if err = sqlgraph.UpdateNode(ctx, uuo.driver, _spec); err != nil {
-		if _, ok := err.(*sqlgraph.NotFoundError); ok {
-			err = &NotFoundError{user.Label}
-		} else if sqlgraph.IsConstraintError(err) {
-			err = &ConstraintError{msg: err.Error(), wrap: err}
-		}
-		return nil, err
-	}
-	uuo.mutation.done = true
-	return _node, nil
-}
diff --git a/backend/database/database.go b/database/database.go
similarity index 50%
rename from backend/database/database.go
rename to database/database.go
index 5afa1b6..e42c20c 100644
--- a/backend/database/database.go
+++ b/database/database.go
@@ -2,31 +2,23 @@ package database
 
 import (
 	"context"
-	"github.com/joho/godotenv"
 	"log"
 	"os"
-	"portfolio/backend/database/ent"
+	"portfolio/database/ent"
 
 	_ "github.com/go-sql-driver/mysql"
 )
 
-var DBclient *ent.Client
+var Client *ent.Client
 
 func DB() {
-
-	err := godotenv.Load()
-	if err != nil {
-		return
-	}
-
-	client, err := ent.Open("mysql", os.Getenv("DB_STRING"))
+	err := *new(error)
+	Client, err = ent.Open("mysql", os.Getenv("DB_STRING"))
 	if err != nil {
 		log.Fatalf("failed opening connection to mysql: %v", err)
 	}
 	// Run the auto migration tool.
-	if err := client.Schema.Create(context.Background()); err != nil {
+	if err := Client.Schema.Create(context.Background()); err != nil {
 		log.Fatalf("failed creating schema resources: %v", err)
 	}
-
-	DBclient = client
 }
diff --git a/backend/database/ent/generate.go b/database/ent/generate.go
similarity index 100%
rename from backend/database/ent/generate.go
rename to database/ent/generate.go
diff --git a/backend/database/ent/schema/project.go b/database/ent/schema/project.go
similarity index 100%
rename from backend/database/ent/schema/project.go
rename to database/ent/schema/project.go
diff --git a/backend/database/ent/schema/team.go b/database/ent/schema/team.go
similarity index 100%
rename from backend/database/ent/schema/team.go
rename to database/ent/schema/team.go
diff --git a/backend/database/ent/schema/user.go b/database/ent/schema/user.go
similarity index 100%
rename from backend/database/ent/schema/user.go
rename to database/ent/schema/user.go
diff --git a/backend/database/query/userQuery.go b/database/query/userQuery.go
similarity index 100%
rename from backend/database/query/userQuery.go
rename to database/query/userQuery.go
diff --git a/go.mod b/go.mod
index 90307a9..287c1f0 100644
--- a/go.mod
+++ b/go.mod
@@ -3,13 +3,14 @@ module portfolio
 go 1.22
 
 require (
-	entgo.io/ent v0.13.0
-	github.com/go-sql-driver/mysql v1.7.1
+	entgo.io/ent v0.13.1
+	github.com/go-sql-driver/mysql v1.8.0
 	github.com/joho/godotenv v1.5.1
 )
 
 require (
 	ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43 // indirect
+	filippo.io/edwards25519 v1.1.0 // indirect
 	github.com/agext/levenshtein v1.2.3 // indirect
 	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
 	github.com/go-openapi/inflect v0.19.0 // indirect
diff --git a/go.sum b/go.sum
index b5f681a..02b43de 100644
--- a/go.sum
+++ b/go.sum
@@ -2,6 +2,10 @@ ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43 h1:GwdJbXydHCYPedeeLt4x/lrl
 ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43/go.mod h1:uj3pm+hUTVN/X5yfdBexHlZv+1Xu5u5ZbZx7+CDavNU=
 entgo.io/ent v0.13.0 h1:DclxWczaCpyiKn6ZWVcJjq1zIKtJ11iNKy+08lNYsJE=
 entgo.io/ent v0.13.0/go.mod h1:+oU8oGna69xy29O+g+NEz+/TM7yJDhQQGJfuOWq1pT8=
+entgo.io/ent v0.13.1 h1:uD8QwN1h6SNphdCCzmkMN3feSUzNnVvV/WIkHKMbzOE=
+entgo.io/ent v0.13.1/go.mod h1:qCEmo+biw3ccBn9OyL4ZK5dfpwg++l1Gxwac5B1206A=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
 github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
@@ -14,6 +18,8 @@ github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNP
 github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
 github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
 github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-sql-driver/mysql v1.8.0 h1:UtktXaU2Nb64z/pLiGIxY4431SJ4/dR5cjMmlVHgnT4=
+github.com/go-sql-driver/mysql v1.8.0/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
 github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
 github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
@@ -58,5 +64,7 @@ golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc=
 golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
+golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ=
+golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/main.go b/main.go
index 8b032da..69d04fd 100644
--- a/main.go
+++ b/main.go
@@ -1,25 +1,32 @@
 package main
 
 import (
+	"github.com/joho/godotenv"
+	"log"
 	"net/http"
-	"portfolio/backend/api/handler"
-	"portfolio/backend/database"
+	api2 "portfolio/api"
+	"portfolio/database"
 )
 
 func main() {
+	// load .env in runtime environment
+	err := godotenv.Load()
+	if err != nil {
+		log.Fatalf(".env not found: %v", err)
+		return
+	}
 
 	// Create a new request multiplexer
-	// Take incoming requests and dispatch them to the matching handlers
+	// Take incoming requests and dispatch them to the matching webHandler
 	mux := http.NewServeMux()
 
+	api2.WebRoutes(&mux)
+
+	api2.ApiRoutes(&mux)
+
 	//connect to database and migrate
 	database.DB()
 
-	// Register the routes and handlers
-	mux.HandleFunc("/", handler.CatchAllHandler)
-	mux.HandleFunc("POST /user", handler.CreateUser)
-	mux.HandleFunc("GET /user/{id}", handler.GetUser)
-
 	// Run the server
 	http.ListenAndServe(":4002", mux)
 }
diff --git a/templates/index.html b/templates/index.html
new file mode 100644
index 0000000..02853d2
--- /dev/null
+++ b/templates/index.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>HTMX & Go - Demo</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-KK94CHFLLe+nY2dmCWGMq91rCGa5gtU4mk92HdvYe+M/SXH301p5ILy+dN9+nJOZ" crossorigin="anonymous">
+    <script src="https://unpkg.com/htmx.org@1.9.2" integrity="sha384-L6OqL9pRWyyFU3+/bjdSri+iIphTN/bvYyM37tICVyOJkWZLpP2vGn6VUEXgzg6h" crossorigin="anonymous"></script>
+
+</head>
+<body class="container">
+
+<div class="row mt-4 g-4">
+    <div class="col-8">
+        <h1 class="mb-4">Film List</h1>
+
+        <ul class="list-group fs-5 me-5" id="film-list">
+            {{ range .Films }}
+            {{ block "film-list-element" .}}
+            <li class="list-group-item bg-primary text-white">{{ .Title }} - {{ .Director }}</li>
+            {{ end }}
+            {{ end }}
+        </ul>
+    </div>
+
+    <div class="col-4">
+        <h1 class="mb-4">Add Film</h1>
+
+        <form hx-post="/add-film/" hx-target="#film-list" hx-swap="beforeend" hx-indicator="#spinner">
+            <div class="mb-2">
+                <label for="film-title">Title</label>
+                <input type="text" name="title" id="film-title" class="form-control" />
+            </div>
+            <div class="mb-3">
+                <label for="film-director">Director</label>
+                <input type="text" name="director" id="film-director" class="form-control" />
+            </div>
+
+            <button type="submit" class="btn btn-primary">
+                <span class="spinner-border spinner-border-sm htmx-indicator" id="spinner" role="status" aria-hidden="true"></span>
+                Submit
+            </button>
+        </form>
+    </div>
+
+</div>
+
+</body>
+</html>
\ No newline at end of file