ci: add support for manually triggering the build

.gitea/workflows/CI.yaml

@@ -1,6 +1,6 @@
 name: CI
 
-on: [push]
+on: [push, workflow_dispatch]
 
 jobs:
   # These steps build the `gas` docker image.

pkg/codegen/modelgenerate/generate_model.go

@@ -161,79 +161,92 @@ func buildFKCheckLambda(tbl schema.Table) (*ast.AssignStmt, bool) {
 							structFieldName := col.GoFieldName()
 							structField := &ast.SelectorExpr{X: ast.NewIdent(tbl.VarName), Sel: ast.NewIdent(structFieldName)}
 
-							if col.IsNonCodeTableForeignKey() {
+							ret = append(ret, func() ast.Stmt {
-								// Real foreign key; look up referent by ID to see if it exists
+								// Wrap nullable FKs in "if a.val != 0 { ... }"
-								ret = append(ret, &ast.IfStmt{
+								wrap := func(input ast.Stmt) ast.Stmt {
-									Init: &ast.AssignStmt{
+									if col.IsNullableForeignKey() {
-										Lhs: []ast.Expr{ast.NewIdent("_"), ast.NewIdent("err")},
+										return &ast.IfStmt{
-										Tok: token.DEFINE,
+											Cond: &ast.BinaryExpr{X: structField, Op: token.NEQ, Y: &ast.BasicLit{Kind: token.INT, Value: "0"}},
-										Rhs: []ast.Expr{
+											Body: &ast.BlockStmt{List: []ast.Stmt{input}},
-											&ast.CallExpr{
+										}
-												Fun:  &ast.SelectorExpr{X: ast.NewIdent("db"), Sel: ast.NewIdent(getByIDFuncName(col.ForeignKeyTargetTable))},
+									} else {
-												Args: []ast.Expr{structField},
+										return input
+									}
+								}
+								if col.IsNonCodeTableForeignKey() {
+									// Real foreign key; look up referent by ID to see if it exists
+									return wrap(&ast.IfStmt{
+										Init: &ast.AssignStmt{
+											Lhs: []ast.Expr{ast.NewIdent("_"), ast.NewIdent("err")},
+											Tok: token.DEFINE,
+											Rhs: []ast.Expr{
+												&ast.CallExpr{
+													Fun:  &ast.SelectorExpr{X: ast.NewIdent("db"), Sel: ast.NewIdent(getByIDFuncName(col.ForeignKeyTargetTable))},
+													Args: []ast.Expr{structField},
+												},
 											},
 										},
-									},
+										Cond: &ast.CallExpr{
-									Cond: &ast.CallExpr{
+											Fun:  &ast.SelectorExpr{X: ast.NewIdent("errors"), Sel: ast.NewIdent("Is")},
-										Fun:  &ast.SelectorExpr{X: ast.NewIdent("errors"), Sel: ast.NewIdent("Is")},
+											Args: []ast.Expr{ast.NewIdent("err"), ast.NewIdent("ErrNotInDB")},
-										Args: []ast.Expr{ast.NewIdent("err"), ast.NewIdent("ErrNotInDB")},
+										},
-									},
+										Body: &ast.BlockStmt{
-									Body: &ast.BlockStmt{
+											List: []ast.Stmt{
-										List: []ast.Stmt{
+												&ast.ReturnStmt{
-											&ast.ReturnStmt{
+													Results: []ast.Expr{
-												Results: []ast.Expr{
+														&ast.CallExpr{
-													&ast.CallExpr{
+															Fun: ast.NewIdent("NewForeignKeyError"),
-														Fun: ast.NewIdent("NewForeignKeyError"),
+															Args: []ast.Expr{
-														Args: []ast.Expr{
+																&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", structFieldName)},
-															&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", structFieldName)},
+																&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", col.ForeignKeyTargetTable)},
-															&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", col.ForeignKeyTargetTable)},
+																structField,
-															structField,
+															},
 														},
 													},
 												},
 											},
 										},
-									},
+									})
-								})
+								} else {
-							} else {
+									// Code table value.  Query the table to see if it exists
-								// Code table value.  Query the table to see if it exists
+									return wrap(&ast.IfStmt{
-								ret = append(ret, &ast.IfStmt{
+										Init: &ast.AssignStmt{
-									Init: &ast.AssignStmt{
+											Lhs: []ast.Expr{ast.NewIdent("err")},
-										Lhs: []ast.Expr{ast.NewIdent("err")},
+											Tok: token.DEFINE,
-										Tok: token.DEFINE,
+											Rhs: []ast.Expr{
-										Rhs: []ast.Expr{
+												&ast.CallExpr{
-											&ast.CallExpr{
+													Fun: &ast.SelectorExpr{X: dbDB, Sel: ast.NewIdent("Get")},
-												Fun: &ast.SelectorExpr{X: dbDB, Sel: ast.NewIdent("Get")},
+													Args: []ast.Expr{
-												Args: []ast.Expr{
+														&ast.CallExpr{Fun: ast.NewIdent("new"), Args: []ast.Expr{ast.NewIdent("int")}},
-													&ast.CallExpr{Fun: ast.NewIdent("new"), Args: []ast.Expr{ast.NewIdent("int")}},
+														&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("`select 1 from %s where rowid = ?`", col.ForeignKeyTargetTable)},
-													&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("`select 1 from %s where rowid = ?`", col.ForeignKeyTargetTable)},
+														structField,
-													structField,
+													},
 												},
 											},
 										},
-									},
+										Cond: &ast.CallExpr{
-									Cond: &ast.CallExpr{
+											Fun:  &ast.SelectorExpr{X: ast.NewIdent("errors"), Sel: ast.NewIdent("Is")},
-										Fun:  &ast.SelectorExpr{X: ast.NewIdent("errors"), Sel: ast.NewIdent("Is")},
+											Args: []ast.Expr{ast.NewIdent("err"), &ast.SelectorExpr{X: ast.NewIdent("sql"), Sel: ast.NewIdent("ErrNoRows")}},
-										Args: []ast.Expr{ast.NewIdent("err"), &ast.SelectorExpr{X: ast.NewIdent("sql"), Sel: ast.NewIdent("ErrNoRows")}},
+										},
-									},
+										Body: &ast.BlockStmt{
-									Body: &ast.BlockStmt{
+											List: []ast.Stmt{
-										List: []ast.Stmt{
+												&ast.ReturnStmt{
-											&ast.ReturnStmt{
+													Results: []ast.Expr{
-												Results: []ast.Expr{
+														&ast.CallExpr{
-													&ast.CallExpr{
+															Fun: ast.NewIdent("NewForeignKeyError"),
-														Fun: ast.NewIdent("NewForeignKeyError"),
+															Args: []ast.Expr{
-														Args: []ast.Expr{
+																&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", structFieldName)},
-															&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", structFieldName)},
+																&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", col.ForeignKeyTargetTable)},
-															&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", col.ForeignKeyTargetTable)},
+																structField,
-															structField,
+															},
 														},
 													},
 												},
 											},
 										},
-									},
+									})
-								})
+								}
-							}
+							}())
 						}
 						// final return nil
 						ret = append(ret, &ast.ReturnStmt{Results: []ast.Expr{ast.NewIdent("nil")}})
@@ -386,6 +399,24 @@ func GenerateSaveItemFunc(tbl schema.Table) *ast.FuncDecl {
 			}
 
 			if tbl.IsWithoutRowid {
+				if hasCreatedAt {
+					// Auto-timestamps: created_at.  Don't overwrite existing timestamps (e.g., data import / migrations)
+					ret = append(ret, &ast.IfStmt{
+						Cond: &ast.CallExpr{Fun: &ast.SelectorExpr{
+							X:   &ast.SelectorExpr{X: ast.NewIdent(tbl.VarName), Sel: ast.NewIdent("CreatedAt")},
+							Sel: ast.NewIdent("IsZero"),
+						}},
+						Body: &ast.BlockStmt{
+							List: []ast.Stmt{
+								&ast.AssignStmt{
+									Lhs: []ast.Expr{&ast.SelectorExpr{X: ast.NewIdent(tbl.VarName), Sel: ast.NewIdent("CreatedAt")}},
+									Tok: token.ASSIGN,
+									Rhs: []ast.Expr{&ast.CallExpr{Fun: ast.NewIdent("TimestampNow"), Args: []ast.Expr{}}},
+								},
+							},
+						},
+					})
+				}
 				ret = append(ret, namedExecStmt(upsertStmt)...)
 				ret = append(ret, PanicIfRowsAffected(tbl))
 			} else {
@@ -403,10 +434,21 @@ func GenerateSaveItemFunc(tbl schema.Table) *ast.FuncDecl {
 								ret1 := []ast.Stmt{Comment("Do create")}
 								if hasCreatedAt {
 									// Auto-timestamps: created_at
-									ret1 = append(ret1, &ast.AssignStmt{
+									ret1 = append(ret1, &ast.IfStmt{
-										Lhs: []ast.Expr{&ast.SelectorExpr{X: ast.NewIdent(tbl.VarName), Sel: ast.NewIdent("CreatedAt")}},
+										// Don't overwrite existing timestamps.  This is useful for various reasons, e.g., data import / migrations
-										Tok: token.ASSIGN,
+										Cond: &ast.CallExpr{Fun: &ast.SelectorExpr{
-										Rhs: []ast.Expr{&ast.CallExpr{Fun: ast.NewIdent("TimestampNow"), Args: []ast.Expr{}}},
+											X:   &ast.SelectorExpr{X: ast.NewIdent(tbl.VarName), Sel: ast.NewIdent("CreatedAt")},
+											Sel: ast.NewIdent("IsZero"),
+										}},
+										Body: &ast.BlockStmt{
+											List: []ast.Stmt{
+												&ast.AssignStmt{
+													Lhs: []ast.Expr{&ast.SelectorExpr{X: ast.NewIdent(tbl.VarName), Sel: ast.NewIdent("CreatedAt")}},
+													Tok: token.ASSIGN,
+													Rhs: []ast.Expr{&ast.CallExpr{Fun: ast.NewIdent("TimestampNow"), Args: []ast.Expr{}}},
+												},
+											},
+										},
 									})
 								}
 								return append(ret1, namedExecStmt(insertStmt)...)
@@ -477,7 +519,7 @@ func GenerateGetItemBy(tbl schema.Table, cols []schema.Column) *ast.FuncDecl {
 	for _, col := range cols {
 		funcParam := ast.NewIdent(col.LongGoVarName())
 		funcParams.List = append(funcParams.List, &ast.Field{Names: []*ast.Ident{funcParam}, Type: GoTypeForColumn(col)})
-		colNames = append(colNames, fmt.Sprintf("%s = :%s", col.Name, col.Name))
+		colNames = append(colNames, fmt.Sprintf("%s = ?", col.Name))
 		funcNameSuffix = append(funcNameSuffix, col.GoFieldName())
 		sqlParams = append(sqlParams, funcParam)
 	}
@@ -489,7 +531,7 @@ func GenerateGetItemBy(tbl schema.Table, cols []schema.Column) *ast.FuncDecl {
 			Y:  SQLFieldsConstIdent(tbl),
 		},
 		Op: token.ADD,
-		Y:  &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("`\n\t      from %s\n\t     where %s = ?\n\t`", tbl.TableName, strings.Join(colNames, " and "))},
+		Y:  &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("`\n\t      from %s\n\t     where %s\n\t`", tbl.TableName, strings.Join(colNames, " and "))},
 	}
 
 	return &ast.FuncDecl{
@@ -515,7 +557,8 @@ func GenerateGetItemBy(tbl schema.Table, cols []schema.Column) *ast.FuncDecl {
 				&ast.IfStmt{
 					Cond: &ast.CallExpr{
 						Fun:  &ast.SelectorExpr{X: ast.NewIdent("errors"), Sel: ast.NewIdent("Is")},
-						Args: []ast.Expr{ast.NewIdent("err"), &ast.SelectorExpr{X: ast.NewIdent("sql"), Sel: ast.NewIdent("ErrNoRows")}}},
+						Args: []ast.Expr{ast.NewIdent("err"), &ast.SelectorExpr{X: ast.NewIdent("sql"), Sel: ast.NewIdent("ErrNoRows")}},
+					},
 					Body: &ast.BlockStmt{List: []ast.Stmt{&ast.ReturnStmt{Results: []ast.Expr{&ast.CompositeLit{Type: ast.NewIdent(tbl.GoTypeName)}, ast.NewIdent("ErrNotInDB")}}}},
 				},
 				&ast.ReturnStmt{},