From 18b785700771ab25aaa19a460cb441bb1f149607 Mon Sep 17 00:00:00 2001 From: darius Date: Wed, 13 Mar 2024 14:39:10 +0100 Subject: [PATCH] reformat van backend naar fullstack part 2 --- .idea/portfolio.iml | 2 + api/apiRoutes.go | 14 + {backend/api => api}/handler/errorHandlers.go | 0 api/handler/homepage.go | 18 + {backend/api => api}/handler/mainHandler.go | 0 .../api => api}/handler/projectHandler.go | 0 {backend/api => api}/handler/userHandler.go | 4 +- api/webRoutes.go | 12 + backend/database/ent/client.go | 692 -------- backend/database/ent/ent.go | 612 ------- backend/database/ent/enttest/enttest.go | 84 - backend/database/ent/hook/hook.go | 222 --- backend/database/ent/migrate/migrate.go | 64 - backend/database/ent/migrate/schema.go | 92 -- backend/database/ent/mutation.go | 1399 ----------------- backend/database/ent/predicate/predicate.go | 16 - backend/database/ent/project.go | 144 -- backend/database/ent/project/project.go | 82 - backend/database/ent/project/where.go | 163 -- backend/database/ent/project_create.go | 220 --- backend/database/ent/project_delete.go | 88 -- backend/database/ent/project_query.go | 613 -------- backend/database/ent/project_update.go | 318 ---- backend/database/ent/runtime.go | 20 - backend/database/ent/runtime/runtime.go | 10 - backend/database/ent/team.go | 145 -- backend/database/ent/team/team.go | 112 -- backend/database/ent/team/where.go | 186 --- backend/database/ent/team_create.go | 247 --- backend/database/ent/team_delete.go | 88 -- backend/database/ent/team_query.go | 711 --------- backend/database/ent/team_update.go | 535 ------- backend/database/ent/tx.go | 216 --- backend/database/ent/user.go | 140 -- backend/database/ent/user/user.go | 121 -- backend/database/ent/user/where.go | 183 --- backend/database/ent/user_create.go | 251 --- backend/database/ent/user_delete.go | 88 -- backend/database/ent/user_query.go | 636 -------- backend/database/ent/user_update.go | 432 ----- {backend/database => database}/database.go | 18 +- .../database => database}/ent/generate.go | 0 .../ent/schema/project.go | 0 .../database => database}/ent/schema/team.go | 0 .../database => database}/ent/schema/user.go | 0 .../database => database}/query/userQuery.go | 0 go.mod | 5 +- go.sum | 8 + main.go | 23 +- templates/index.html | 50 + 50 files changed, 129 insertions(+), 8955 deletions(-) create mode 100644 api/apiRoutes.go rename {backend/api => api}/handler/errorHandlers.go (100%) create mode 100644 api/handler/homepage.go rename {backend/api => api}/handler/mainHandler.go (100%) rename {backend/api => api}/handler/projectHandler.go (100%) rename {backend/api => api}/handler/userHandler.go (91%) create mode 100644 api/webRoutes.go delete mode 100644 backend/database/ent/client.go delete mode 100644 backend/database/ent/ent.go delete mode 100644 backend/database/ent/enttest/enttest.go delete mode 100644 backend/database/ent/hook/hook.go delete mode 100644 backend/database/ent/migrate/migrate.go delete mode 100644 backend/database/ent/migrate/schema.go delete mode 100644 backend/database/ent/mutation.go delete mode 100644 backend/database/ent/predicate/predicate.go delete mode 100644 backend/database/ent/project.go delete mode 100644 backend/database/ent/project/project.go delete mode 100644 backend/database/ent/project/where.go delete mode 100644 backend/database/ent/project_create.go delete mode 100644 backend/database/ent/project_delete.go delete mode 100644 backend/database/ent/project_query.go delete mode 100644 backend/database/ent/project_update.go delete mode 100644 backend/database/ent/runtime.go delete mode 100644 backend/database/ent/runtime/runtime.go delete mode 100644 backend/database/ent/team.go delete mode 100644 backend/database/ent/team/team.go delete mode 100644 backend/database/ent/team/where.go delete mode 100644 backend/database/ent/team_create.go delete mode 100644 backend/database/ent/team_delete.go delete mode 100644 backend/database/ent/team_query.go delete mode 100644 backend/database/ent/team_update.go delete mode 100644 backend/database/ent/tx.go delete mode 100644 backend/database/ent/user.go delete mode 100644 backend/database/ent/user/user.go delete mode 100644 backend/database/ent/user/where.go delete mode 100644 backend/database/ent/user_create.go delete mode 100644 backend/database/ent/user_delete.go delete mode 100644 backend/database/ent/user_query.go delete mode 100644 backend/database/ent/user_update.go rename {backend/database => database}/database.go (50%) rename {backend/database => database}/ent/generate.go (100%) rename {backend/database => database}/ent/schema/project.go (100%) rename {backend/database => database}/ent/schema/team.go (100%) rename {backend/database => database}/ent/schema/user.go (100%) rename {backend/database => database}/query/userQuery.go (100%) create mode 100644 templates/index.html 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 @@ + + \ 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 @@ + + + + + + + HTMX & Go - Demo + + + + + + +
+
+

Film List

+ +
    + {{ range .Films }} + {{ block "film-list-element" .}} +
  • {{ .Title }} - {{ .Director }}
    • + {{ end }} + {{ end }} +
+
+ +
+

Add Film

+ +
+
+ + +
+
+ + +
+ + +
+
+ +
+ + + \ No newline at end of file