165 lines
3.1 KiB
Go
165 lines
3.1 KiB
Go
package serv
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/dosco/super-graph/psql"
|
|
"github.com/dosco/super-graph/qcode"
|
|
)
|
|
|
|
func addTables(c *config, di *psql.DBInfo) error {
|
|
for _, t := range c.Tables {
|
|
if len(t.Table) == 0 || len(t.Columns) == 0 {
|
|
continue
|
|
}
|
|
if err := addTable(di, t.Columns, t); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addTable(di *psql.DBInfo, cols []configColumn, t configTable) error {
|
|
bc, ok := di.GetColumn(t.Table, t.Name)
|
|
if !ok {
|
|
return fmt.Errorf(
|
|
"Column '%s' not found on table '%s'",
|
|
t.Name, t.Table)
|
|
}
|
|
|
|
if bc.Type != "json" && bc.Type != "jsonb" {
|
|
return fmt.Errorf(
|
|
"Column '%s' in table '%s' is of type '%s'. Only JSON or JSONB is valid",
|
|
t.Name, t.Table, bc.Type)
|
|
}
|
|
|
|
table := psql.DBTable{
|
|
Name: t.Name,
|
|
Key: strings.ToLower(t.Name),
|
|
Type: bc.Type,
|
|
}
|
|
|
|
columns := make([]psql.DBColumn, 0, len(cols))
|
|
|
|
for i := range cols {
|
|
c := cols[i]
|
|
columns = append(columns, psql.DBColumn{
|
|
Name: c.Name,
|
|
Key: strings.ToLower(c.Name),
|
|
Type: c.Type,
|
|
})
|
|
}
|
|
|
|
di.AddTable(table, columns)
|
|
bc.FKeyTable = t.Name
|
|
|
|
return nil
|
|
}
|
|
|
|
func addForeignKeys(c *config, di *psql.DBInfo) error {
|
|
for _, t := range c.Tables {
|
|
for _, c := range t.Columns {
|
|
if len(c.ForeignKey) == 0 {
|
|
continue
|
|
}
|
|
if err := addForeignKey(di, c, t); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addForeignKey(di *psql.DBInfo, c configColumn, t configTable) error {
|
|
c1, ok := di.GetColumn(t.Name, c.Name)
|
|
if !ok {
|
|
return fmt.Errorf(
|
|
"Invalid table '%s' or column '%s' in config",
|
|
t.Name, c.Name)
|
|
}
|
|
|
|
v := strings.SplitN(c.ForeignKey, ".", 2)
|
|
if len(v) != 2 {
|
|
return fmt.Errorf(
|
|
"Invalid foreign_key in config for table '%s' and column '%s",
|
|
t.Name, c.Name)
|
|
}
|
|
|
|
fkt, fkc := v[0], v[1]
|
|
c2, ok := di.GetColumn(fkt, fkc)
|
|
if !ok {
|
|
return fmt.Errorf(
|
|
"Invalid foreign_key in config for table '%s' and column '%s",
|
|
t.Name, c.Name)
|
|
}
|
|
|
|
c1.FKeyTable = fkt
|
|
c1.FKeyColID = []int16{c2.ID}
|
|
|
|
return nil
|
|
}
|
|
|
|
func addRoles(c *config, qc *qcode.Compiler) error {
|
|
for _, r := range c.Roles {
|
|
for _, t := range r.Tables {
|
|
if err := addRole(qc, r, t); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func addRole(qc *qcode.Compiler, r configRole, t configRoleTable) error {
|
|
blockFilter := []string{"false"}
|
|
|
|
query := qcode.QueryConfig{
|
|
Limit: t.Query.Limit,
|
|
Filters: t.Query.Filters,
|
|
Columns: t.Query.Columns,
|
|
DisableFunctions: t.Query.DisableFunctions,
|
|
}
|
|
|
|
if t.Query.Block {
|
|
query.Filters = blockFilter
|
|
}
|
|
|
|
insert := qcode.InsertConfig{
|
|
Filters: t.Insert.Filters,
|
|
Columns: t.Insert.Columns,
|
|
Presets: t.Insert.Presets,
|
|
}
|
|
|
|
if t.Insert.Block {
|
|
insert.Filters = blockFilter
|
|
}
|
|
|
|
update := qcode.UpdateConfig{
|
|
Filters: t.Update.Filters,
|
|
Columns: t.Update.Columns,
|
|
Presets: t.Update.Presets,
|
|
}
|
|
|
|
if t.Update.Block {
|
|
update.Filters = blockFilter
|
|
}
|
|
|
|
delete := qcode.DeleteConfig{
|
|
Filters: t.Delete.Filters,
|
|
Columns: t.Delete.Columns,
|
|
}
|
|
|
|
if t.Delete.Block {
|
|
delete.Filters = blockFilter
|
|
}
|
|
|
|
return qc.AddRole(r.Name, t.Name, qcode.TRConfig{
|
|
Query: query,
|
|
Insert: insert,
|
|
Update: update,
|
|
Delete: delete,
|
|
})
|
|
}
|