···

       
8
       
8
       
 
       
	"github.com/go-git/go-git/v5/plumbing"

     

       
9
       
9
       
 
       
	"github.com/ipfs/go-cid"

     

       
10
       
10
       
 
       
	"tangled.org/core/appview/models"

     

       
11
       
11
       
+
       
	"tangled.org/core/orm"

     

       
11
       
12
       
 
       
)

     

       
12
       
13
       
 
       


     

       
13
       
14
       
 
       
func AddArtifact(e Execer, artifact models.Artifact) error {

     
···

       
37
       
38
       
 
       
	return err

     

       
38
       
39
       
 
       
}

     

       
39
       
40
       
 
       


     

       
40
       
40
       
-
       
func GetArtifact(e Execer, filters ...filter) ([]models.Artifact, error) {

     

       
41
       
41
       
+
       
func GetArtifact(e Execer, filters ...orm.Filter) ([]models.Artifact, error) {

     

       
41
       
42
       
 
       
	var artifacts []models.Artifact

     

       
42
       
43
       
 
       


     

       
43
       
44
       
 
       
	var conditions []string

     
···

       
109
       
110
       
 
       
	return artifacts, nil

     

       
110
       
111
       
 
       
}

     

       
111
       
112
       
 
       


     

       
112
       
112
       
-
       
func DeleteArtifact(e Execer, filters ...filter) error {

     

       
113
       
113
       
+
       
func DeleteArtifact(e Execer, filters ...orm.Filter) error {

     

       
113
       
114
       
 
       
	var conditions []string

     

       
114
       
115
       
 
       
	var args []any

     

       
115
       
116
       
 
       
	for _, filter := range filters {

     

···

       
6
       
6
       
 
       
	"time"

     

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
	"tangled.org/core/appview/models"

     

       
9
       
9
       
+
       
	"tangled.org/core/orm"

     

       
9
       
10
       
 
       
)

     

       
10
       
11
       
 
       


     

       
11
       
12
       
 
       
func AddCollaborator(e Execer, c models.Collaborator) error {

     
···

       
16
       
17
       
 
       
	return err

     

       
17
       
18
       
 
       
}

     

       
18
       
19
       
 
       


     

       
19
       
19
       
-
       
func DeleteCollaborator(e Execer, filters ...filter) error {

     

       
20
       
20
       
+
       
func DeleteCollaborator(e Execer, filters ...orm.Filter) error {

     

       
20
       
21
       
 
       
	var conditions []string

     

       
21
       
22
       
 
       
	var args []any

     

       
22
       
23
       
 
       
	for _, filter := range filters {

     
···

       
58
       
59
       
 
       
		return nil, nil

     

       
59
       
60
       
 
       
	}

     

       
60
       
61
       
 
       


     

       
61
       
61
       
-
       
	return GetRepos(e, 0, FilterIn("at_uri", repoAts))

     

       
62
       
62
       
+
       
	return GetRepos(e, 0, orm.FilterIn("at_uri", repoAts))

     

       
62
       
63
       
 
       
}

     

       
63
       
64
       
 
       


     

       
64
       
64
       
-
       
func GetCollaborators(e Execer, filters ...filter) ([]models.Collaborator, error) {

     

       
65
       
65
       
+
       
func GetCollaborators(e Execer, filters ...orm.Filter) ([]models.Collaborator, error) {

     

       
65
       
66
       
 
       
	var collaborators []models.Collaborator

     

       
66
       
67
       
 
       
	var conditions []string

     

       
67
       
68
       
 
       
	var args []any

     

···

       
3
       
3
       
 
       
import (

     

       
4
       
4
       
 
       
	"context"

     

       
5
       
5
       
 
       
	"database/sql"

     

       
6
       
6
       
-
       
	"fmt"

     

       
7
       
6
       
 
       
	"log/slog"

     

       
8
       
8
       
-
       
	"reflect"

     

       
9
       
7
       
 
       
	"strings"

     

       
10
       
8
       
 
       


     

       
11
       
9
       
 
       
	_ "github.com/mattn/go-sqlite3"

     

       
12
       
10
       
 
       
	"tangled.org/core/log"

     

       
11
       
11
       
+
       
	"tangled.org/core/orm"

     

       
13
       
12
       
 
       
)

     

       
14
       
13
       
 
       


     

       
15
       
14
       
 
       
type DB struct {

     
···

       
584
       
583
       
 
       
	}

     

       
585
       
584
       
 
       


     

       
586
       
585
       
 
       
	// run migrations

     

       
587
       
587
       
-
       
	runMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       
586
       
586
       
+
       
	orm.RunMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       
588
       
587
       
 
       
		tx.Exec(`

     

       
589
       
588
       
 
       
			alter table repos add column description text check (length(description) <= 200);

     

       
590
       
589
       
 
       
		`)

     

       
591
       
590
       
 
       
		return nil

     

       
592
       
591
       
 
       
	})

     

       
593
       
592
       
 
       


     

       
594
       
594
       
-
       
	runMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       
593
       
593
       
+
       
	orm.RunMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       
595
       
594
       
 
       
		// add unconstrained column

     

       
596
       
595
       
 
       
		_, err := tx.Exec(`

     

       
597
       
596
       
 
       
			alter table public_keys

     
···

       
614
       
613
       
 
       
		return nil

     

       
615
       
614
       
 
       
	})

     

       
616
       
615
       
 
       


     

       
617
       
617
       
-
       
	runMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       
616
       
616
       
+
       
	orm.RunMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       
618
       
617
       
 
       
		_, err := tx.Exec(`

     

       
619
       
618
       
 
       
			alter table comments drop column comment_at;

     

       
620
       
619
       
 
       
			alter table comments add column rkey text;

     
···

       
622
       
621
       
 
       
		return err

     

       
623
       
622
       
 
       
	})

     

       
624
       
623
       
 
       


     

       
625
       
625
       
-
       
	runMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       
624
       
624
       
+
       
	orm.RunMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       
626
       
625
       
 
       
		_, err := tx.Exec(`

     

       
627
       
626
       
 
       
			alter table comments add column deleted text; -- timestamp

     

       
628
       
627
       
 
       
			alter table comments add column edited text; -- timestamp

     
···

       
630
       
629
       
 
       
		return err

     

       
631
       
630
       
 
       
	})

     

       
632
       
631
       
 
       


     

       
633
       
633
       
-
       
	runMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       
632
       
632
       
+
       
	orm.RunMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       
634
       
633
       
 
       
		_, err := tx.Exec(`

     

       
635
       
634
       
 
       
			alter table pulls add column source_branch text;

     

       
636
       
635
       
 
       
			alter table pulls add column source_repo_at text;

     
···

       
639
       
638
       
 
       
		return err

     

       
640
       
639
       
 
       
	})

     

       
641
       
640
       
 
       


     

       
642
       
642
       
-
       
	runMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       
641
       
641
       
+
       
	orm.RunMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       
643
       
642
       
 
       
		_, err := tx.Exec(`

     

       
644
       
643
       
 
       
			alter table repos add column source text;

     

       
645
       
644
       
 
       
		`)

     
···

       
651
       
650
       
 
       
	//

     

       
652
       
651
       
 
       
	// [0]: https://sqlite.org/pragma.html#pragma_foreign_keys

     

       
653
       
652
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
654
       
654
       
-
       
	runMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       
653
       
653
       
+
       
	orm.RunMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       
655
       
654
       
 
       
		_, err := tx.Exec(`

     

       
656
       
655
       
 
       
			create table pulls_new (

     

       
657
       
656
       
 
       
				-- identifiers

     
···

       
708
       
707
       
 
       
	})

     

       
709
       
708
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       
710
       
709
       
 
       


     

       
711
       
711
       
-
       
	runMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       
710
       
710
       
+
       
	orm.RunMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       
712
       
711
       
 
       
		tx.Exec(`

     

       
713
       
712
       
 
       
			alter table repos add column spindle text;

     

       
714
       
713
       
 
       
		`)

     
···

       
718
       
717
       
 
       
	// drop all knot secrets, add unique constraint to knots

     

       
719
       
718
       
 
       
	//

     

       
720
       
719
       
 
       
	// knots will henceforth use service auth for signed requests

     

       
721
       
721
       
-
       
	runMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       
720
       
720
       
+
       
	orm.RunMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       
722
       
721
       
 
       
		_, err := tx.Exec(`

     

       
723
       
722
       
 
       
			create table registrations_new (

     

       
724
       
723
       
 
       
				id integer primary key autoincrement,

     
···

       
741
       
740
       
 
       
	})

     

       
742
       
741
       
 
       


     

       
743
       
742
       
 
       
	// recreate and add rkey + created columns with default constraint

     

       
744
       
744
       
-
       
	runMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       
743
       
743
       
+
       
	orm.RunMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       
745
       
744
       
 
       
		// create new table

     

       
746
       
745
       
 
       
		// - repo_at instead of repo integer

     

       
747
       
746
       
 
       
		// - rkey field

     
···

       
795
       
794
       
 
       
		return err

     

       
796
       
795
       
 
       
	})

     

       
797
       
796
       
 
       


     

       
798
       
798
       
-
       
	runMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       
797
       
797
       
+
       
	orm.RunMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       
799
       
798
       
 
       
		_, err := tx.Exec(`

     

       
800
       
799
       
 
       
			alter table issues add column rkey text not null default '';

     

       
801
       
800
       
 
       


     
···

       
807
       
806
       
 
       
	})

     

       
808
       
807
       
 
       


     

       
809
       
808
       
 
       
	// repurpose the read-only column to "needs-upgrade"

     

       
810
       
810
       
-
       
	runMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       
809
       
809
       
+
       
	orm.RunMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       
811
       
810
       
 
       
		_, err := tx.Exec(`

     

       
812
       
811
       
 
       
			alter table registrations rename column read_only to needs_upgrade;

     

       
813
       
812
       
 
       
		`)

     
···

       
815
       
814
       
 
       
	})

     

       
816
       
815
       
 
       


     

       
817
       
816
       
 
       
	// require all knots to upgrade after the release of total xrpc

     

       
818
       
818
       
-
       
	runMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       
817
       
817
       
+
       
	orm.RunMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       
819
       
818
       
 
       
		_, err := tx.Exec(`

     

       
820
       
819
       
 
       
			update registrations set needs_upgrade = 1;

     

       
821
       
820
       
 
       
		`)

     
···

       
823
       
822
       
 
       
	})

     

       
824
       
823
       
 
       


     

       
825
       
824
       
 
       
	// require all knots to upgrade after the release of total xrpc

     

       
826
       
826
       
-
       
	runMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       
825
       
825
       
+
       
	orm.RunMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       
827
       
826
       
 
       
		_, err := tx.Exec(`

     

       
828
       
827
       
 
       
			alter table spindles add column needs_upgrade integer not null default 0;

     

       
829
       
828
       
 
       
		`)

     
···

       
841
       
840
       
 
       
	//

     

       
842
       
841
       
 
       
	// disable foreign-keys for the next migration

     

       
843
       
842
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
844
       
844
       
-
       
	runMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       
843
       
843
       
+
       
	orm.RunMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       
845
       
844
       
 
       
		_, err := tx.Exec(`

     

       
846
       
845
       
 
       
			create table if not exists issues_new (

     

       
847
       
846
       
 
       
				-- identifiers

     
···

       
911
       
910
       
 
       
	// - new columns

     

       
912
       
911
       
 
       
	//   * column "reply_to" which can be any other comment

     

       
913
       
912
       
 
       
	//   * column "at-uri" which is a generated column

     

       
914
       
914
       
-
       
	runMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       
913
       
913
       
+
       
	orm.RunMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       
915
       
914
       
 
       
		_, err := tx.Exec(`

     

       
916
       
915
       
 
       
			create table if not exists issue_comments (

     

       
917
       
916
       
 
       
				-- identifiers

     
···

       
971
       
970
       
 
       
	//

     

       
972
       
971
       
 
       
	// disable foreign-keys for the next migration

     

       
973
       
972
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
974
       
974
       
-
       
	runMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       
973
       
973
       
+
       
	orm.RunMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       
975
       
974
       
 
       
		_, err := tx.Exec(`

     

       
976
       
975
       
 
       
		create table if not exists pulls_new (

     

       
977
       
976
       
 
       
			-- identifiers

     
···

       
1052
       
1051
       
 
       
	//

     

       
1053
       
1052
       
 
       
	// disable foreign-keys for the next migration

     

       
1054
       
1053
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
1055
       
1055
       
-
       
	runMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       
1054
       
1054
       
+
       
	orm.RunMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       
1056
       
1055
       
 
       
		_, err := tx.Exec(`

     

       
1057
       
1056
       
 
       
		create table if not exists pull_submissions_new (

     

       
1058
       
1057
       
 
       
			-- identifiers

     
···

       
1106
       
1105
       
 
       


     

       
1107
       
1106
       
 
       
	// knots may report the combined patch for a comparison, we can store that on the appview side

     

       
1108
       
1107
       
 
       
	// (but not on the pds record), because calculating the combined patch requires a git index

     

       
1109
       
1109
       
-
       
	runMigration(conn, logger, "add-combined-column-submissions", func(tx *sql.Tx) error {

     

       
1108
       
1108
       
+
       
	orm.RunMigration(conn, logger, "add-combined-column-submissions", func(tx *sql.Tx) error {

     

       
1110
       
1109
       
 
       
		_, err := tx.Exec(`

     

       
1111
       
1110
       
 
       
			alter table pull_submissions add column combined text;

     

       
1112
       
1111
       
 
       
		`)

     

       
1113
       
1112
       
 
       
		return err

     

       
1114
       
1113
       
 
       
	})

     

       
1115
       
1114
       
 
       


     

       
1116
       
1116
       
-
       
	runMigration(conn, logger, "add-pronouns-profile", func(tx *sql.Tx) error {

     

       
1115
       
1115
       
+
       
	orm.RunMigration(conn, logger, "add-pronouns-profile", func(tx *sql.Tx) error {

     

       
1117
       
1116
       
 
       
		_, err := tx.Exec(`

     

       
1118
       
1117
       
 
       
			alter table profile add column pronouns text;

     

       
1119
       
1118
       
 
       
		`)

     

       
1120
       
1119
       
 
       
		return err

     

       
1121
       
1120
       
 
       
	})

     

       
1122
       
1121
       
 
       


     

       
1123
       
1123
       
-
       
	runMigration(conn, logger, "add-meta-column-repos", func(tx *sql.Tx) error {

     

       
1122
       
1122
       
+
       
	orm.RunMigration(conn, logger, "add-meta-column-repos", func(tx *sql.Tx) error {

     

       
1124
       
1123
       
 
       
		_, err := tx.Exec(`

     

       
1125
       
1124
       
 
       
			alter table repos add column website text;

     

       
1126
       
1125
       
 
       
			alter table repos add column topics text;

     
···

       
1128
       
1127
       
 
       
		return err

     

       
1129
       
1128
       
 
       
	})

     

       
1130
       
1129
       
 
       


     

       
1131
       
1131
       
-
       
	runMigration(conn, logger, "add-usermentioned-preference", func(tx *sql.Tx) error {

     

       
1130
       
1130
       
+
       
	orm.RunMigration(conn, logger, "add-usermentioned-preference", func(tx *sql.Tx) error {

     

       
1132
       
1131
       
 
       
		_, err := tx.Exec(`

     

       
1133
       
1132
       
 
       
			alter table notification_preferences add column user_mentioned integer not null default 1;

     

       
1134
       
1133
       
 
       
		`)

     
···

       
1136
       
1135
       
 
       
	})

     

       
1137
       
1136
       
 
       


     

       
1138
       
1137
       
 
       
	// remove the foreign key constraints from stars.

     

       
1139
       
1139
       
-
       
	runMigration(conn, logger, "generalize-stars-subject", func(tx *sql.Tx) error {

     

       
1138
       
1138
       
+
       
	orm.RunMigration(conn, logger, "generalize-stars-subject", func(tx *sql.Tx) error {

     

       
1140
       
1139
       
 
       
		_, err := tx.Exec(`

     

       
1141
       
1140
       
 
       
			create table stars_new (

     

       
1142
       
1141
       
 
       
				id integer primary key autoincrement,

     
···

       
1180
       
1179
       
 
       
	}, nil

     

       
1181
       
1180
       
 
       
}

     

       
1182
       
1181
       
 
       


     

       
1183
       
1183
       
-
       
type migrationFn = func(*sql.Tx) error

     

       
1184
       
1184
       
-
       


     

       
1185
       
1185
       
-
       
func runMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error {

     

       
1186
       
1186
       
-
       
	logger = logger.With("migration", name)

     

       
1187
       
1187
       
-
       


     

       
1188
       
1188
       
-
       
	tx, err := c.BeginTx(context.Background(), nil)

     

       
1189
       
1189
       
-
       
	if err != nil {

     

       
1190
       
1190
       
-
       
		return err

     

       
1191
       
1191
       
-
       
	}

     

       
1192
       
1192
       
-
       
	defer tx.Rollback()

     

       
1193
       
1193
       
-
       


     

       
1194
       
1194
       
-
       
	var exists bool

     

       
1195
       
1195
       
-
       
	err = tx.QueryRow("select exists (select 1 from migrations where name = ?)", name).Scan(&exists)

     

       
1196
       
1196
       
-
       
	if err != nil {

     

       
1197
       
1197
       
-
       
		return err

     

       
1198
       
1198
       
-
       
	}

     

       
1199
       
1199
       
-
       


     

       
1200
       
1200
       
-
       
	if !exists {

     

       
1201
       
1201
       
-
       
		// run migration

     

       
1202
       
1202
       
-
       
		err = migrationFn(tx)

     

       
1203
       
1203
       
-
       
		if err != nil {

     

       
1204
       
1204
       
-
       
			logger.Error("failed to run migration", "err", err)

     

       
1205
       
1205
       
-
       
			return err

     

       
1206
       
1206
       
-
       
		}

     

       
1207
       
1207
       
-
       


     

       
1208
       
1208
       
-
       
		// mark migration as complete

     

       
1209
       
1209
       
-
       
		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       
1210
       
1210
       
-
       
		if err != nil {

     

       
1211
       
1211
       
-
       
			logger.Error("failed to mark migration as complete", "err", err)

     

       
1212
       
1212
       
-
       
			return err

     

       
1213
       
1213
       
-
       
		}

     

       
1214
       
1214
       
-
       


     

       
1215
       
1215
       
-
       
		// commit the transaction

     

       
1216
       
1216
       
-
       
		if err := tx.Commit(); err != nil {

     

       
1217
       
1217
       
-
       
			return err

     

       
1218
       
1218
       
-
       
		}

     

       
1219
       
1219
       
-
       


     

       
1220
       
1220
       
-
       
		logger.Info("migration applied successfully")

     

       
1221
       
1221
       
-
       
	} else {

     

       
1222
       
1222
       
-
       
		logger.Warn("skipped migration, already applied")

     

       
1223
       
1223
       
-
       
	}

     

       
1224
       
1224
       
-
       


     

       
1225
       
1225
       
-
       
	return nil

     

       
1226
       
1226
       
-
       
}

     

       
1227
       
1227
       
-
       


     

       
1228
       
1182
       
 
       
func (d *DB) Close() error {

     

       
1229
       
1183
       
 
       
	return d.DB.Close()

     

       
1230
       
1184
       
 
       
}

     

       
1231
       
1231
       
-
       


     

       
1232
       
1232
       
-
       
type filter struct {

     

       
1233
       
1233
       
-
       
	key string

     

       
1234
       
1234
       
-
       
	arg any

     

       
1235
       
1235
       
-
       
	cmp string

     

       
1236
       
1236
       
-
       
}

     

       
1237
       
1237
       
-
       


     

       
1238
       
1238
       
-
       
func newFilter(key, cmp string, arg any) filter {

     

       
1239
       
1239
       
-
       
	return filter{

     

       
1240
       
1240
       
-
       
		key: key,

     

       
1241
       
1241
       
-
       
		arg: arg,

     

       
1242
       
1242
       
-
       
		cmp: cmp,

     

       
1243
       
1243
       
-
       
	}

     

       
1244
       
1244
       
-
       
}

     

       
1245
       
1245
       
-
       


     

       
1246
       
1246
       
-
       
func FilterEq(key string, arg any) filter      { return newFilter(key, "=", arg) }

     

       
1247
       
1247
       
-
       
func FilterNotEq(key string, arg any) filter   { return newFilter(key, "<>", arg) }

     

       
1248
       
1248
       
-
       
func FilterGte(key string, arg any) filter     { return newFilter(key, ">=", arg) }

     

       
1249
       
1249
       
-
       
func FilterLte(key string, arg any) filter     { return newFilter(key, "<=", arg) }

     

       
1250
       
1250
       
-
       
func FilterIs(key string, arg any) filter      { return newFilter(key, "is", arg) }

     

       
1251
       
1251
       
-
       
func FilterIsNot(key string, arg any) filter   { return newFilter(key, "is not", arg) }

     

       
1252
       
1252
       
-
       
func FilterIn(key string, arg any) filter      { return newFilter(key, "in", arg) }

     

       
1253
       
1253
       
-
       
func FilterLike(key string, arg any) filter    { return newFilter(key, "like", arg) }

     

       
1254
       
1254
       
-
       
func FilterNotLike(key string, arg any) filter { return newFilter(key, "not like", arg) }

     

       
1255
       
1255
       
-
       
func FilterContains(key string, arg any) filter {

     

       
1256
       
1256
       
-
       
	return newFilter(key, "like", fmt.Sprintf("%%%v%%", arg))

     

       
1257
       
1257
       
-
       
}

     

       
1258
       
1258
       
-
       


     

       
1259
       
1259
       
-
       
func (f filter) Condition() string {

     

       
1260
       
1260
       
-
       
	rv := reflect.ValueOf(f.arg)

     

       
1261
       
1261
       
-
       
	kind := rv.Kind()

     

       
1262
       
1262
       
-
       


     

       
1263
       
1263
       
-
       
	// if we have `FilterIn(k, [1, 2, 3])`, compile it down to `k in (?, ?, ?)`

     

       
1264
       
1264
       
-
       
	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       
1265
       
1265
       
-
       
		if rv.Len() == 0 {

     

       
1266
       
1266
       
-
       
			// always false

     

       
1267
       
1267
       
-
       
			return "1 = 0"

     

       
1268
       
1268
       
-
       
		}

     

       
1269
       
1269
       
-
       


     

       
1270
       
1270
       
-
       
		placeholders := make([]string, rv.Len())

     

       
1271
       
1271
       
-
       
		for i := range placeholders {

     

       
1272
       
1272
       
-
       
			placeholders[i] = "?"

     

       
1273
       
1273
       
-
       
		}

     

       
1274
       
1274
       
-
       


     

       
1275
       
1275
       
-
       
		return fmt.Sprintf("%s %s (%s)", f.key, f.cmp, strings.Join(placeholders, ", "))

     

       
1276
       
1276
       
-
       
	}

     

       
1277
       
1277
       
-
       


     

       
1278
       
1278
       
-
       
	return fmt.Sprintf("%s %s ?", f.key, f.cmp)

     

       
1279
       
1279
       
-
       
}

     

       
1280
       
1280
       
-
       


     

       
1281
       
1281
       
-
       
func (f filter) Arg() []any {

     

       
1282
       
1282
       
-
       
	rv := reflect.ValueOf(f.arg)

     

       
1283
       
1283
       
-
       
	kind := rv.Kind()

     

       
1284
       
1284
       
-
       
	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       
1285
       
1285
       
-
       
		if rv.Len() == 0 {

     

       
1286
       
1286
       
-
       
			return nil

     

       
1287
       
1287
       
-
       
		}

     

       
1288
       
1288
       
-
       


     

       
1289
       
1289
       
-
       
		out := make([]any, rv.Len())

     

       
1290
       
1290
       
-
       
		for i := range rv.Len() {

     

       
1291
       
1291
       
-
       
			out[i] = rv.Index(i).Interface()

     

       
1292
       
1292
       
-
       
		}

     

       
1293
       
1293
       
-
       
		return out

     

       
1294
       
1294
       
-
       
	}

     

       
1295
       
1295
       
-
       


     

       
1296
       
1296
       
-
       
	return []any{f.arg}

     

       
1297
       
1297
       
-
       
}

     

···

       
7
       
7
       
 
       
	"time"

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
	"tangled.org/core/appview/models"

     

       
10
       
10
       
+
       
	"tangled.org/core/orm"

     

       
10
       
11
       
 
       
)

     

       
11
       
12
       
 
       


     

       
12
       
13
       
 
       
func AddFollow(e Execer, follow *models.Follow) error {

     
···

       
134
       
135
       
 
       
	return result, nil

     

       
135
       
136
       
 
       
}

     

       
136
       
137
       
 
       


     

       
137
       
137
       
-
       
func GetFollows(e Execer, limit int, filters ...filter) ([]models.Follow, error) {

     

       
138
       
138
       
+
       
func GetFollows(e Execer, limit int, filters ...orm.Filter) ([]models.Follow, error) {

     

       
138
       
139
       
 
       
	var follows []models.Follow

     

       
139
       
140
       
 
       


     

       
140
       
141
       
 
       
	var conditions []string

     
···

       
191
       
192
       
 
       
}

     

       
192
       
193
       
 
       


     

       
193
       
194
       
 
       
func GetFollowers(e Execer, did string) ([]models.Follow, error) {

     

       
194
       
194
       
-
       
	return GetFollows(e, 0, FilterEq("subject_did", did))

     

       
195
       
195
       
+
       
	return GetFollows(e, 0, orm.FilterEq("subject_did", did))

     

       
195
       
196
       
 
       
}

     

       
196
       
197
       
 
       


     

       
197
       
198
       
 
       
func GetFollowing(e Execer, did string) ([]models.Follow, error) {

     

       
198
       
198
       
-
       
	return GetFollows(e, 0, FilterEq("user_did", did))

     

       
199
       
199
       
+
       
	return GetFollows(e, 0, orm.FilterEq("user_did", did))

     

       
199
       
200
       
 
       
}

     

       
200
       
201
       
 
       


     

       
201
       
202
       
 
       
func getFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]models.FollowStatus, error) {

     

···

       
13
       
13
       
 
       
	"tangled.org/core/api/tangled"

     

       
14
       
14
       
 
       
	"tangled.org/core/appview/models"

     

       
15
       
15
       
 
       
	"tangled.org/core/appview/pagination"

     

       
16
       
16
       
+
       
	"tangled.org/core/orm"

     

       
16
       
17
       
 
       
)

     

       
17
       
18
       
 
       


     

       
18
       
19
       
 
       
func PutIssue(tx *sql.Tx, issue *models.Issue) error {

     
···

       
27
       
28
       
 
       


     

       
28
       
29
       
 
       
	issues, err := GetIssues(

     

       
29
       
30
       
 
       
		tx,

     

       
30
       
30
       
-
       
		FilterEq("did", issue.Did),

     

       
31
       
31
       
-
       
		FilterEq("rkey", issue.Rkey),

     

       
31
       
31
       
+
       
		orm.FilterEq("did", issue.Did),

     

       
32
       
32
       
+
       
		orm.FilterEq("rkey", issue.Rkey),

     

       
32
       
33
       
 
       
	)

     

       
33
       
34
       
 
       
	switch {

     

       
34
       
35
       
 
       
	case err != nil:

     
···

       
98
       
99
       
 
       
	return nil

     

       
99
       
100
       
 
       
}

     

       
100
       
101
       
 
       


     

       
101
       
101
       
-
       
func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]models.Issue, error) {

     

       
102
       
102
       
+
       
func GetIssuesPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]models.Issue, error) {

     

       
102
       
103
       
 
       
	issueMap := make(map[string]*models.Issue) // at-uri -> issue

     

       
103
       
104
       
 
       


     

       
104
       
105
       
 
       
	var conditions []string

     
···

       
114
       
115
       
 
       
		whereClause = " where " + strings.Join(conditions, " and ")

     

       
115
       
116
       
 
       
	}

     

       
116
       
117
       
 
       


     

       
117
       
117
       
-
       
	pLower := FilterGte("row_num", page.Offset+1)

     

       
118
       
118
       
-
       
	pUpper := FilterLte("row_num", page.Offset+page.Limit)

     

       
118
       
118
       
+
       
	pLower := orm.FilterGte("row_num", page.Offset+1)

     

       
119
       
119
       
+
       
	pUpper := orm.FilterLte("row_num", page.Offset+page.Limit)

     

       
119
       
120
       
 
       


     

       
120
       
121
       
 
       
	pageClause := ""

     

       
121
       
122
       
 
       
	if page.Limit > 0 {

     
···

       
205
       
206
       
 
       
		repoAts = append(repoAts, string(issue.RepoAt))

     

       
206
       
207
       
 
       
	}

     

       
207
       
208
       
 
       


     

       
208
       
208
       
-
       
	repos, err := GetRepos(e, 0, FilterIn("at_uri", repoAts))

     

       
209
       
209
       
+
       
	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", repoAts))

     

       
209
       
210
       
 
       
	if err != nil {

     

       
210
       
211
       
 
       
		return nil, fmt.Errorf("failed to build repo mappings: %w", err)

     

       
211
       
212
       
 
       
	}

     
···

       
228
       
229
       
 
       
	// collect comments

     

       
229
       
230
       
 
       
	issueAts := slices.Collect(maps.Keys(issueMap))

     

       
230
       
231
       
 
       


     

       
231
       
231
       
-
       
	comments, err := GetIssueComments(e, FilterIn("issue_at", issueAts))

     

       
232
       
232
       
+
       
	comments, err := GetIssueComments(e, orm.FilterIn("issue_at", issueAts))

     

       
232
       
233
       
 
       
	if err != nil {

     

       
233
       
234
       
 
       
		return nil, fmt.Errorf("failed to query comments: %w", err)

     

       
234
       
235
       
 
       
	}

     
···

       
240
       
241
       
 
       
	}

     

       
241
       
242
       
 
       


     

       
242
       
243
       
 
       
	// collect allLabels for each issue

     

       
243
       
243
       
-
       
	allLabels, err := GetLabels(e, FilterIn("subject", issueAts))

     

       
244
       
244
       
+
       
	allLabels, err := GetLabels(e, orm.FilterIn("subject", issueAts))

     

       
244
       
245
       
 
       
	if err != nil {

     

       
245
       
246
       
 
       
		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       
246
       
247
       
 
       
	}

     
···

       
251
       
252
       
 
       
	}

     

       
252
       
253
       
 
       


     

       
253
       
254
       
 
       
	// collect references for each issue

     

       
254
       
254
       
-
       
	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", issueAts))

     

       
255
       
255
       
+
       
	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", issueAts))

     

       
255
       
256
       
 
       
	if err != nil {

     

       
256
       
257
       
 
       
		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       
257
       
258
       
 
       
	}

     
···

       
277
       
278
       
 
       
	issues, err := GetIssuesPaginated(

     

       
278
       
279
       
 
       
		e,

     

       
279
       
280
       
 
       
		pagination.Page{},

     

       
280
       
280
       
-
       
		FilterEq("repo_at", repoAt),

     

       
281
       
281
       
-
       
		FilterEq("issue_id", issueId),

     

       
281
       
281
       
+
       
		orm.FilterEq("repo_at", repoAt),

     

       
282
       
282
       
+
       
		orm.FilterEq("issue_id", issueId),

     

       
282
       
283
       
 
       
	)

     

       
283
       
284
       
 
       
	if err != nil {

     

       
284
       
285
       
 
       
		return nil, err

     
···

       
290
       
291
       
 
       
	return &issues[0], nil

     

       
291
       
292
       
 
       
}

     

       
292
       
293
       
 
       


     

       
293
       
293
       
-
       
func GetIssues(e Execer, filters ...filter) ([]models.Issue, error) {

     

       
294
       
294
       
+
       
func GetIssues(e Execer, filters ...orm.Filter) ([]models.Issue, error) {

     

       
294
       
295
       
 
       
	return GetIssuesPaginated(e, pagination.Page{}, filters...)

     

       
295
       
296
       
 
       
}

     

       
296
       
297
       
 
       


     
···

       
298
       
299
       
 
       
func GetIssueIDs(e Execer, opts models.IssueSearchOptions) ([]int64, error) {

     

       
299
       
300
       
 
       
	var ids []int64

     

       
300
       
301
       
 
       


     

       
301
       
301
       
-
       
	var filters []filter

     

       
302
       
302
       
+
       
	var filters []orm.Filter

     

       
302
       
303
       
 
       
	openValue := 0

     

       
303
       
304
       
 
       
	if opts.IsOpen {

     

       
304
       
305
       
 
       
		openValue = 1

     

       
305
       
306
       
 
       
	}

     

       
306
       
306
       
-
       
	filters = append(filters, FilterEq("open", openValue))

     

       
307
       
307
       
+
       
	filters = append(filters, orm.FilterEq("open", openValue))

     

       
307
       
308
       
 
       
	if opts.RepoAt != "" {

     

       
308
       
308
       
-
       
		filters = append(filters, FilterEq("repo_at", opts.RepoAt))

     

       
309
       
309
       
+
       
		filters = append(filters, orm.FilterEq("repo_at", opts.RepoAt))

     

       
309
       
310
       
 
       
	}

     

       
310
       
311
       
 
       


     

       
311
       
312
       
 
       
	var conditions []string

     
···

       
397
       
398
       
 
       
	return id, nil

     

       
398
       
399
       
 
       
}

     

       
399
       
400
       
 
       


     

       
400
       
400
       
-
       
func DeleteIssueComments(e Execer, filters ...filter) error {

     

       
401
       
401
       
+
       
func DeleteIssueComments(e Execer, filters ...orm.Filter) error {

     

       
401
       
402
       
 
       
	var conditions []string

     

       
402
       
403
       
 
       
	var args []any

     

       
403
       
404
       
 
       
	for _, filter := range filters {

     
···

       
416
       
417
       
 
       
	return err

     

       
417
       
418
       
 
       
}

     

       
418
       
419
       
 
       


     

       
419
       
419
       
-
       
func GetIssueComments(e Execer, filters ...filter) ([]models.IssueComment, error) {

     

       
420
       
420
       
+
       
func GetIssueComments(e Execer, filters ...orm.Filter) ([]models.IssueComment, error) {

     

       
420
       
421
       
 
       
	commentMap := make(map[string]*models.IssueComment)

     

       
421
       
422
       
 
       


     

       
422
       
423
       
 
       
	var conditions []string

     
···

       
506
       
507
       
 
       


     

       
507
       
508
       
 
       
	// collect references for each comments

     

       
508
       
509
       
 
       
	commentAts := slices.Collect(maps.Keys(commentMap))

     

       
509
       
509
       
-
       
	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts))

     

       
510
       
510
       
+
       
	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts))

     

       
510
       
511
       
 
       
	if err != nil {

     

       
511
       
512
       
 
       
		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       
512
       
513
       
 
       
	}

     
···

       
548
       
549
       
 
       
	return nil

     

       
549
       
550
       
 
       
}

     

       
550
       
551
       
 
       


     

       
551
       
551
       
-
       
func CloseIssues(e Execer, filters ...filter) error {

     

       
552
       
552
       
+
       
func CloseIssues(e Execer, filters ...orm.Filter) error {

     

       
552
       
553
       
 
       
	var conditions []string

     

       
553
       
554
       
 
       
	var args []any

     

       
554
       
555
       
 
       
	for _, filter := range filters {

     
···

       
566
       
567
       
 
       
	return err

     

       
567
       
568
       
 
       
}

     

       
568
       
569
       
 
       


     

       
569
       
569
       
-
       
func ReopenIssues(e Execer, filters ...filter) error {

     

       
570
       
570
       
+
       
func ReopenIssues(e Execer, filters ...orm.Filter) error {

     

       
570
       
571
       
 
       
	var conditions []string

     

       
571
       
572
       
 
       
	var args []any

     

       
572
       
573
       
 
       
	for _, filter := range filters {

     

···

       
10
       
10
       
 
       


     

       
11
       
11
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
12
       
12
       
 
       
	"tangled.org/core/appview/models"

     

       
13
       
13
       
+
       
	"tangled.org/core/orm"

     

       
13
       
14
       
 
       
)

     

       
14
       
15
       
 
       


     

       
15
       
16
       
 
       
// no updating type for now

     
···

       
59
       
60
       
 
       
	return id, nil

     

       
60
       
61
       
 
       
}

     

       
61
       
62
       
 
       


     

       
62
       
62
       
-
       
func DeleteLabelDefinition(e Execer, filters ...filter) error {

     

       
63
       
63
       
+
       
func DeleteLabelDefinition(e Execer, filters ...orm.Filter) error {

     

       
63
       
64
       
 
       
	var conditions []string

     

       
64
       
65
       
 
       
	var args []any

     

       
65
       
66
       
 
       
	for _, filter := range filters {

     
···

       
75
       
76
       
 
       
	return err

     

       
76
       
77
       
 
       
}

     

       
77
       
78
       
 
       


     

       
78
       
78
       
-
       
func GetLabelDefinitions(e Execer, filters ...filter) ([]models.LabelDefinition, error) {

     

       
79
       
79
       
+
       
func GetLabelDefinitions(e Execer, filters ...orm.Filter) ([]models.LabelDefinition, error) {

     

       
79
       
80
       
 
       
	var labelDefinitions []models.LabelDefinition

     

       
80
       
81
       
 
       
	var conditions []string

     

       
81
       
82
       
 
       
	var args []any

     
···

       
167
       
168
       
 
       
}

     

       
168
       
169
       
 
       


     

       
169
       
170
       
 
       
// helper to get exactly one label def

     

       
170
       
170
       
-
       
func GetLabelDefinition(e Execer, filters ...filter) (*models.LabelDefinition, error) {

     

       
171
       
171
       
+
       
func GetLabelDefinition(e Execer, filters ...orm.Filter) (*models.LabelDefinition, error) {

     

       
171
       
172
       
 
       
	labels, err := GetLabelDefinitions(e, filters...)

     

       
172
       
173
       
 
       
	if err != nil {

     

       
173
       
174
       
 
       
		return nil, err

     
···

       
227
       
228
       
 
       
	return id, nil

     

       
228
       
229
       
 
       
}

     

       
229
       
230
       
 
       


     

       
230
       
230
       
-
       
func GetLabelOps(e Execer, filters ...filter) ([]models.LabelOp, error) {

     

       
231
       
231
       
+
       
func GetLabelOps(e Execer, filters ...orm.Filter) ([]models.LabelOp, error) {

     

       
231
       
232
       
 
       
	var labelOps []models.LabelOp

     

       
232
       
233
       
 
       
	var conditions []string

     

       
233
       
234
       
 
       
	var args []any

     
···

       
302
       
303
       
 
       
}

     

       
303
       
304
       
 
       


     

       
304
       
305
       
 
       
// get labels for a given list of subject URIs

     

       
305
       
305
       
-
       
func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]models.LabelState, error) {

     

       
306
       
306
       
+
       
func GetLabels(e Execer, filters ...orm.Filter) (map[syntax.ATURI]models.LabelState, error) {

     

       
306
       
307
       
 
       
	ops, err := GetLabelOps(e, filters...)

     

       
307
       
308
       
 
       
	if err != nil {

     

       
308
       
309
       
 
       
		return nil, err

     
···

       
322
       
323
       
 
       
	}

     

       
323
       
324
       
 
       
	labelAts := slices.Collect(maps.Keys(labelAtSet))

     

       
324
       
325
       
 
       


     

       
325
       
325
       
-
       
	actx, err := NewLabelApplicationCtx(e, FilterIn("at_uri", labelAts))

     

       
326
       
326
       
+
       
	actx, err := NewLabelApplicationCtx(e, orm.FilterIn("at_uri", labelAts))

     

       
326
       
327
       
 
       
	if err != nil {

     

       
327
       
328
       
 
       
		return nil, err

     

       
328
       
329
       
 
       
	}

     
···

       
338
       
339
       
 
       
	return results, nil

     

       
339
       
340
       
 
       
}

     

       
340
       
341
       
 
       


     

       
341
       
341
       
-
       
func NewLabelApplicationCtx(e Execer, filters ...filter) (*models.LabelApplicationCtx, error) {

     

       
342
       
342
       
+
       
func NewLabelApplicationCtx(e Execer, filters ...orm.Filter) (*models.LabelApplicationCtx, error) {

     

       
342
       
343
       
 
       
	labels, err := GetLabelDefinitions(e, filters...)

     

       
343
       
344
       
 
       
	if err != nil {

     

       
344
       
345
       
 
       
		return nil, err

     

···

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
9
       
9
       
 
       
	"tangled.org/core/appview/models"

     

       
10
       
10
       
+
       
	"tangled.org/core/orm"

     

       
10
       
11
       
 
       
)

     

       
11
       
12
       
 
       


     

       
12
       
12
       
-
       
func GetRepoLanguages(e Execer, filters ...filter) ([]models.RepoLanguage, error) {

     

       
13
       
13
       
+
       
func GetRepoLanguages(e Execer, filters ...orm.Filter) ([]models.RepoLanguage, error) {

     

       
13
       
14
       
 
       
	var conditions []string

     

       
14
       
15
       
 
       
	var args []any

     

       
15
       
16
       
 
       
	for _, filter := range filters {

     
···

       
85
       
86
       
 
       
	return nil

     

       
86
       
87
       
 
       
}

     

       
87
       
88
       
 
       


     

       
88
       
88
       
-
       
func DeleteRepoLanguages(e Execer, filters ...filter) error {

     

       
89
       
89
       
+
       
func DeleteRepoLanguages(e Execer, filters ...orm.Filter) error {

     

       
89
       
90
       
 
       
	var conditions []string

     

       
90
       
91
       
 
       
	var args []any

     

       
91
       
92
       
 
       
	for _, filter := range filters {

     
···

       
107
       
108
       
 
       
func UpdateRepoLanguages(tx *sql.Tx, repoAt syntax.ATURI, ref string, langs []models.RepoLanguage) error {

     

       
108
       
109
       
 
       
	err := DeleteRepoLanguages(

     

       
109
       
110
       
 
       
		tx,

     

       
110
       
110
       
-
       
		FilterEq("repo_at", repoAt),

     

       
111
       
111
       
-
       
		FilterEq("ref", ref),

     

       
111
       
111
       
+
       
		orm.FilterEq("repo_at", repoAt),

     

       
112
       
112
       
+
       
		orm.FilterEq("ref", ref),

     

       
112
       
113
       
 
       
	)

     

       
113
       
114
       
 
       
	if err != nil {

     

       
114
       
115
       
 
       
		return fmt.Errorf("failed to delete existing languages: %w", err)

     

···

       
11
       
11
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
12
       
12
       
 
       
	"tangled.org/core/appview/models"

     

       
13
       
13
       
 
       
	"tangled.org/core/appview/pagination"

     

       
14
       
14
       
+
       
	"tangled.org/core/orm"

     

       
14
       
15
       
 
       
)

     

       
15
       
16
       
 
       


     

       
16
       
17
       
 
       
func CreateNotification(e Execer, notification *models.Notification) error {

     
···

       
44
       
45
       
 
       
}

     

       
45
       
46
       
 
       


     

       
46
       
47
       
 
       
// GetNotificationsPaginated retrieves notifications with filters and pagination

     

       
47
       
47
       
-
       
func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...filter) ([]*models.Notification, error) {

     

       
48
       
48
       
+
       
func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]*models.Notification, error) {

     

       
48
       
49
       
 
       
	var conditions []string

     

       
49
       
50
       
 
       
	var args []any

     

       
50
       
51
       
 
       


     
···

       
113
       
114
       
 
       
}

     

       
114
       
115
       
 
       


     

       
115
       
116
       
 
       
// GetNotificationsWithEntities retrieves notifications with their related entities

     

       
116
       
116
       
-
       
func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...filter) ([]*models.NotificationWithEntity, error) {

     

       
117
       
117
       
+
       
func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...orm.Filter) ([]*models.NotificationWithEntity, error) {

     

       
117
       
118
       
 
       
	var conditions []string

     

       
118
       
119
       
 
       
	var args []any

     

       
119
       
120
       
 
       


     
···

       
256
       
257
       
 
       
}

     

       
257
       
258
       
 
       


     

       
258
       
259
       
 
       
// GetNotifications retrieves notifications with filters

     

       
259
       
259
       
-
       
func GetNotifications(e Execer, filters ...filter) ([]*models.Notification, error) {

     

       
260
       
260
       
+
       
func GetNotifications(e Execer, filters ...orm.Filter) ([]*models.Notification, error) {

     

       
260
       
261
       
 
       
	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)

     

       
261
       
262
       
 
       
}

     

       
262
       
263
       
 
       


     

       
263
       
263
       
-
       
func CountNotifications(e Execer, filters ...filter) (int64, error) {

     

       
264
       
264
       
+
       
func CountNotifications(e Execer, filters ...orm.Filter) (int64, error) {

     

       
264
       
265
       
 
       
	var conditions []string

     

       
265
       
266
       
 
       
	var args []any

     

       
266
       
267
       
 
       
	for _, filter := range filters {

     
···

       
285
       
286
       
 
       
}

     

       
286
       
287
       
 
       


     

       
287
       
288
       
 
       
func MarkNotificationRead(e Execer, notificationID int64, userDID string) error {

     

       
288
       
288
       
-
       
	idFilter := FilterEq("id", notificationID)

     

       
289
       
289
       
-
       
	recipientFilter := FilterEq("recipient_did", userDID)

     

       
289
       
289
       
+
       
	idFilter := orm.FilterEq("id", notificationID)

     

       
290
       
290
       
+
       
	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       
290
       
291
       
 
       


     

       
291
       
292
       
 
       
	query := fmt.Sprintf(`

     

       
292
       
293
       
 
       
		UPDATE notifications

     
···

       
314
       
315
       
 
       
}

     

       
315
       
316
       
 
       


     

       
316
       
317
       
 
       
func MarkAllNotificationsRead(e Execer, userDID string) error {

     

       
317
       
317
       
-
       
	recipientFilter := FilterEq("recipient_did", userDID)

     

       
318
       
318
       
-
       
	readFilter := FilterEq("read", 0)

     

       
318
       
318
       
+
       
	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       
319
       
319
       
+
       
	readFilter := orm.FilterEq("read", 0)

     

       
319
       
320
       
 
       


     

       
320
       
321
       
 
       
	query := fmt.Sprintf(`

     

       
321
       
322
       
 
       
		UPDATE notifications

     
···

       
334
       
335
       
 
       
}

     

       
335
       
336
       
 
       


     

       
336
       
337
       
 
       
func DeleteNotification(e Execer, notificationID int64, userDID string) error {

     

       
337
       
337
       
-
       
	idFilter := FilterEq("id", notificationID)

     

       
338
       
338
       
-
       
	recipientFilter := FilterEq("recipient_did", userDID)

     

       
338
       
338
       
+
       
	idFilter := orm.FilterEq("id", notificationID)

     

       
339
       
339
       
+
       
	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       
339
       
340
       
 
       


     

       
340
       
341
       
 
       
	query := fmt.Sprintf(`

     

       
341
       
342
       
 
       
		DELETE FROM notifications

     
···

       
362
       
363
       
 
       
}

     

       
363
       
364
       
 
       


     

       
364
       
365
       
 
       
func GetNotificationPreference(e Execer, userDid string) (*models.NotificationPreferences, error) {

     

       
365
       
365
       
-
       
	prefs, err := GetNotificationPreferences(e, FilterEq("user_did", userDid))

     

       
366
       
366
       
+
       
	prefs, err := GetNotificationPreferences(e, orm.FilterEq("user_did", userDid))

     

       
366
       
367
       
 
       
	if err != nil {

     

       
367
       
368
       
 
       
		return nil, err

     

       
368
       
369
       
 
       
	}

     
···

       
375
       
376
       
 
       
	return p, nil

     

       
376
       
377
       
 
       
}

     

       
377
       
378
       
 
       


     

       
378
       
378
       
-
       
func GetNotificationPreferences(e Execer, filters ...filter) (map[syntax.DID]*models.NotificationPreferences, error) {

     

       
379
       
379
       
+
       
func GetNotificationPreferences(e Execer, filters ...orm.Filter) (map[syntax.DID]*models.NotificationPreferences, error) {

     

       
379
       
380
       
 
       
	prefsMap := make(map[syntax.DID]*models.NotificationPreferences)

     

       
380
       
381
       
 
       


     

       
381
       
382
       
 
       
	var conditions []string

     
···

       
483
       
484
       
 
       


     

       
484
       
485
       
 
       
func (d *DB) ClearOldNotifications(ctx context.Context, olderThan time.Duration) error {

     

       
485
       
486
       
 
       
	cutoff := time.Now().Add(-olderThan)

     

       
486
       
486
       
-
       
	createdFilter := FilterLte("created", cutoff)

     

       
487
       
487
       
+
       
	createdFilter := orm.FilterLte("created", cutoff)

     

       
487
       
488
       
 
       


     

       
488
       
489
       
 
       
	query := fmt.Sprintf(`

     

       
489
       
490
       
 
       
		DELETE FROM notifications

     

···

       
7
       
7
       
 
       
	"time"

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
	"tangled.org/core/appview/models"

     

       
10
       
10
       
+
       
	"tangled.org/core/orm"

     

       
10
       
11
       
 
       
)

     

       
11
       
12
       
 
       


     

       
12
       
12
       
-
       
func GetPipelines(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       
13
       
13
       
+
       
func GetPipelines(e Execer, filters ...orm.Filter) ([]models.Pipeline, error) {

     

       
13
       
14
       
 
       
	var pipelines []models.Pipeline

     

       
14
       
15
       
 
       


     

       
15
       
16
       
 
       
	var conditions []string

     
···

       
168
       
169
       
 
       


     

       
169
       
170
       
 
       
// this is a mega query, but the most useful one:

     

       
170
       
171
       
 
       
// get N pipelines, for each one get the latest status of its N workflows

     

       
171
       
171
       
-
       
func GetPipelineStatuses(e Execer, limit int, filters ...filter) ([]models.Pipeline, error) {

     

       
172
       
172
       
+
       
func GetPipelineStatuses(e Execer, limit int, filters ...orm.Filter) ([]models.Pipeline, error) {

     

       
172
       
173
       
 
       
	var conditions []string

     

       
173
       
174
       
 
       
	var args []any

     

       
174
       
175
       
 
       
	for _, filter := range filters {

     

       
175
       
175
       
-
       
		filter.key = "p." + filter.key // the table is aliased in the query to `p`

     

       
176
       
176
       
+
       
		filter.Key = "p." + filter.Key // the table is aliased in the query to `p`

     

       
176
       
177
       
 
       
		conditions = append(conditions, filter.Condition())

     

       
177
       
178
       
 
       
		args = append(args, filter.Arg()...)

     

       
178
       
179
       
 
       
	}

     
···

       
264
       
265
       
 
       
	conditions = nil

     

       
265
       
266
       
 
       
	args = nil

     

       
266
       
267
       
 
       
	for _, p := range pipelines {

     

       
267
       
267
       
-
       
		knotFilter := FilterEq("pipeline_knot", p.Knot)

     

       
268
       
268
       
-
       
		rkeyFilter := FilterEq("pipeline_rkey", p.Rkey)

     

       
268
       
268
       
+
       
		knotFilter := orm.FilterEq("pipeline_knot", p.Knot)

     

       
269
       
269
       
+
       
		rkeyFilter := orm.FilterEq("pipeline_rkey", p.Rkey)

     

       
269
       
270
       
 
       
		conditions = append(conditions, fmt.Sprintf("(%s and %s)", knotFilter.Condition(), rkeyFilter.Condition()))

     

       
270
       
271
       
 
       
		args = append(args, p.Knot)

     

       
271
       
272
       
 
       
		args = append(args, p.Rkey)

     

···

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
13
       
13
       
 
       
	"tangled.org/core/appview/models"

     

       
14
       
14
       
+
       
	"tangled.org/core/orm"

     

       
14
       
15
       
 
       
)

     

       
15
       
16
       
 
       


     

       
16
       
17
       
 
       
const TimeframeMonths = 7

     
···

       
44
       
45
       
 
       


     

       
45
       
46
       
 
       
	issues, err := GetIssues(

     

       
46
       
47
       
 
       
		e,

     

       
47
       
47
       
-
       
		FilterEq("did", forDid),

     

       
48
       
48
       
-
       
		FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)),

     

       
48
       
48
       
+
       
		orm.FilterEq("did", forDid),

     

       
49
       
49
       
+
       
		orm.FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)),

     

       
49
       
50
       
 
       
	)

     

       
50
       
51
       
 
       
	if err != nil {

     

       
51
       
52
       
 
       
		return nil, fmt.Errorf("error getting issues by owner did: %w", err)

     
···

       
65
       
66
       
 
       
		*items = append(*items, &issue)

     

       
66
       
67
       
 
       
	}

     

       
67
       
68
       
 
       


     

       
68
       
68
       
-
       
	repos, err := GetRepos(e, 0, FilterEq("did", forDid))

     

       
69
       
69
       
+
       
	repos, err := GetRepos(e, 0, orm.FilterEq("did", forDid))

     

       
69
       
70
       
 
       
	if err != nil {

     

       
70
       
71
       
 
       
		return nil, fmt.Errorf("error getting all repos by did: %w", err)

     

       
71
       
72
       
 
       
	}

     
···

       
199
       
200
       
 
       
	return tx.Commit()

     

       
200
       
201
       
 
       
}

     

       
201
       
202
       
 
       


     

       
202
       
202
       
-
       
func GetProfiles(e Execer, filters ...filter) (map[string]*models.Profile, error) {

     

       
203
       
203
       
+
       
func GetProfiles(e Execer, filters ...orm.Filter) (map[string]*models.Profile, error) {

     

       
203
       
204
       
 
       
	var conditions []string

     

       
204
       
205
       
 
       
	var args []any

     

       
205
       
206
       
 
       
	for _, filter := range filters {

     
···

       
441
       
442
       
 
       
	}

     

       
442
       
443
       
 
       


     

       
443
       
444
       
 
       
	// ensure all pinned repos are either own repos or collaborating repos

     

       
444
       
444
       
-
       
	repos, err := GetRepos(e, 0, FilterEq("did", profile.Did))

     

       
445
       
445
       
+
       
	repos, err := GetRepos(e, 0, orm.FilterEq("did", profile.Did))

     

       
445
       
446
       
 
       
	if err != nil {

     

       
446
       
447
       
 
       
		log.Printf("getting repos for %s: %s", profile.Did, err)

     

       
447
       
448
       
 
       
	}

     

···

       
13
       
13
       
 
       


     

       
14
       
14
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
15
       
15
       
 
       
	"tangled.org/core/appview/models"

     

       
16
       
16
       
+
       
	"tangled.org/core/orm"

     

       
16
       
17
       
 
       
)

     

       
17
       
18
       
 
       


     

       
18
       
19
       
 
       
func NewPull(tx *sql.Tx, pull *models.Pull) error {

     
···

       
118
       
119
       
 
       
	return pullId - 1, err

     

       
119
       
120
       
 
       
}

     

       
120
       
121
       
 
       


     

       
121
       
121
       
-
       
func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*models.Pull, error) {

     

       
122
       
122
       
+
       
func GetPullsWithLimit(e Execer, limit int, filters ...orm.Filter) ([]*models.Pull, error) {

     

       
122
       
123
       
 
       
	pulls := make(map[syntax.ATURI]*models.Pull)

     

       
123
       
124
       
 
       


     

       
124
       
125
       
 
       
	var conditions []string

     
···

       
229
       
230
       
 
       
	for _, p := range pulls {

     

       
230
       
231
       
 
       
		pullAts = append(pullAts, p.AtUri())

     

       
231
       
232
       
 
       
	}

     

       
232
       
232
       
-
       
	submissionsMap, err := GetPullSubmissions(e, FilterIn("pull_at", pullAts))

     

       
233
       
233
       
+
       
	submissionsMap, err := GetPullSubmissions(e, orm.FilterIn("pull_at", pullAts))

     

       
233
       
234
       
 
       
	if err != nil {

     

       
234
       
235
       
 
       
		return nil, fmt.Errorf("failed to get submissions: %w", err)

     

       
235
       
236
       
 
       
	}

     
···

       
241
       
242
       
 
       
	}

     

       
242
       
243
       
 
       


     

       
243
       
244
       
 
       
	// collect allLabels for each issue

     

       
244
       
244
       
-
       
	allLabels, err := GetLabels(e, FilterIn("subject", pullAts))

     

       
245
       
245
       
+
       
	allLabels, err := GetLabels(e, orm.FilterIn("subject", pullAts))

     

       
245
       
246
       
 
       
	if err != nil {

     

       
246
       
247
       
 
       
		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       
247
       
248
       
 
       
	}

     
···

       
258
       
259
       
 
       
			sourceAts = append(sourceAts, *p.PullSource.RepoAt)

     

       
259
       
260
       
 
       
		}

     

       
260
       
261
       
 
       
	}

     

       
261
       
261
       
-
       
	sourceRepos, err := GetRepos(e, 0, FilterIn("at_uri", sourceAts))

     

       
262
       
262
       
+
       
	sourceRepos, err := GetRepos(e, 0, orm.FilterIn("at_uri", sourceAts))

     

       
262
       
263
       
 
       
	if err != nil && !errors.Is(err, sql.ErrNoRows) {

     

       
263
       
264
       
 
       
		return nil, fmt.Errorf("failed to get source repos: %w", err)

     

       
264
       
265
       
 
       
	}

     
···

       
274
       
275
       
 
       
		}

     

       
275
       
276
       
 
       
	}

     

       
276
       
277
       
 
       


     

       
277
       
277
       
-
       
	allReferences, err := GetReferencesAll(e, FilterIn("from_at", pullAts))

     

       
278
       
278
       
+
       
	allReferences, err := GetReferencesAll(e, orm.FilterIn("from_at", pullAts))

     

       
278
       
279
       
 
       
	if err != nil {

     

       
279
       
280
       
 
       
		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       
280
       
281
       
 
       
	}

     
···

       
295
       
296
       
 
       
	return orderedByPullId, nil

     

       
296
       
297
       
 
       
}

     

       
297
       
298
       
 
       


     

       
298
       
298
       
-
       
func GetPulls(e Execer, filters ...filter) ([]*models.Pull, error) {

     

       
299
       
299
       
+
       
func GetPulls(e Execer, filters ...orm.Filter) ([]*models.Pull, error) {

     

       
299
       
300
       
 
       
	return GetPullsWithLimit(e, 0, filters...)

     

       
300
       
301
       
 
       
}

     

       
301
       
302
       
 
       


     

       
302
       
303
       
 
       
func GetPullIDs(e Execer, opts models.PullSearchOptions) ([]int64, error) {

     

       
303
       
304
       
 
       
	var ids []int64

     

       
304
       
305
       
 
       


     

       
305
       
305
       
-
       
	var filters []filter

     

       
306
       
306
       
-
       
	filters = append(filters, FilterEq("state", opts.State))

     

       
306
       
306
       
+
       
	var filters []orm.Filter

     

       
307
       
307
       
+
       
	filters = append(filters, orm.FilterEq("state", opts.State))

     

       
307
       
308
       
 
       
	if opts.RepoAt != "" {

     

       
308
       
308
       
-
       
		filters = append(filters, FilterEq("repo_at", opts.RepoAt))

     

       
309
       
309
       
+
       
		filters = append(filters, orm.FilterEq("repo_at", opts.RepoAt))

     

       
309
       
310
       
 
       
	}

     

       
310
       
311
       
 
       


     

       
311
       
312
       
 
       
	var conditions []string

     
···

       
361
       
362
       
 
       
}

     

       
362
       
363
       
 
       


     

       
363
       
364
       
 
       
func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*models.Pull, error) {

     

       
364
       
364
       
-
       
	pulls, err := GetPullsWithLimit(e, 1, FilterEq("repo_at", repoAt), FilterEq("pull_id", pullId))

     

       
365
       
365
       
+
       
	pulls, err := GetPullsWithLimit(e, 1, orm.FilterEq("repo_at", repoAt), orm.FilterEq("pull_id", pullId))

     

       
365
       
366
       
 
       
	if err != nil {

     

       
366
       
367
       
 
       
		return nil, err

     

       
367
       
368
       
 
       
	}

     
···

       
373
       
374
       
 
       
}

     

       
374
       
375
       
 
       


     

       
375
       
376
       
 
       
// mapping from pull -> pull submissions

     

       
376
       
376
       
-
       
func GetPullSubmissions(e Execer, filters ...filter) (map[syntax.ATURI][]*models.PullSubmission, error) {

     

       
377
       
377
       
+
       
func GetPullSubmissions(e Execer, filters ...orm.Filter) (map[syntax.ATURI][]*models.PullSubmission, error) {

     

       
377
       
378
       
 
       
	var conditions []string

     

       
378
       
379
       
 
       
	var args []any

     

       
379
       
380
       
 
       
	for _, filter := range filters {

     
···

       
448
       
449
       
 
       


     

       
449
       
450
       
 
       
	// Get comments for all submissions using GetPullComments

     

       
450
       
451
       
 
       
	submissionIds := slices.Collect(maps.Keys(submissionMap))

     

       
451
       
451
       
-
       
	comments, err := GetPullComments(e, FilterIn("submission_id", submissionIds))

     

       
452
       
452
       
+
       
	comments, err := GetPullComments(e, orm.FilterIn("submission_id", submissionIds))

     

       
452
       
453
       
 
       
	if err != nil {

     

       
453
       
454
       
 
       
		return nil, fmt.Errorf("failed to get pull comments: %w", err)

     

       
454
       
455
       
 
       
	}

     
···

       
474
       
475
       
 
       
	return m, nil

     

       
475
       
476
       
 
       
}

     

       
476
       
477
       
 
       


     

       
477
       
477
       
-
       
func GetPullComments(e Execer, filters ...filter) ([]models.PullComment, error) {

     

       
478
       
478
       
+
       
func GetPullComments(e Execer, filters ...orm.Filter) ([]models.PullComment, error) {

     

       
478
       
479
       
 
       
	var conditions []string

     

       
479
       
480
       
 
       
	var args []any

     

       
480
       
481
       
 
       
	for _, filter := range filters {

     
···

       
542
       
543
       
 
       


     

       
543
       
544
       
 
       
	// collect references for each comments

     

       
544
       
545
       
 
       
	commentAts := slices.Collect(maps.Keys(commentMap))

     

       
545
       
545
       
-
       
	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts))

     

       
546
       
546
       
+
       
	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts))

     

       
546
       
547
       
 
       
	if err != nil {

     

       
547
       
548
       
 
       
		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       
548
       
549
       
 
       
	}

     
···

       
708
       
709
       
 
       
	return err

     

       
709
       
710
       
 
       
}

     

       
710
       
711
       
 
       


     

       
711
       
711
       
-
       
func SetPullParentChangeId(e Execer, parentChangeId string, filters ...filter) error {

     

       
712
       
712
       
+
       
func SetPullParentChangeId(e Execer, parentChangeId string, filters ...orm.Filter) error {

     

       
712
       
713
       
 
       
	var conditions []string

     

       
713
       
714
       
 
       
	var args []any

     

       
714
       
715
       
 
       


     
···

       
732
       
733
       
 
       


     

       
733
       
734
       
 
       
// Only used when stacking to update contents in the event of a rebase (the interdiff should be empty).

     

       
734
       
735
       
 
       
// otherwise submissions are immutable

     

       
735
       
735
       
-
       
func UpdatePull(e Execer, newPatch, sourceRev string, filters ...filter) error {

     

       
736
       
736
       
+
       
func UpdatePull(e Execer, newPatch, sourceRev string, filters ...orm.Filter) error {

     

       
736
       
737
       
 
       
	var conditions []string

     

       
737
       
738
       
 
       
	var args []any

     

       
738
       
739
       
 
       


     
···

       
790
       
791
       
 
       
func GetStack(e Execer, stackId string) (models.Stack, error) {

     

       
791
       
792
       
 
       
	unorderedPulls, err := GetPulls(

     

       
792
       
793
       
 
       
		e,

     

       
793
       
793
       
-
       
		FilterEq("stack_id", stackId),

     

       
794
       
794
       
-
       
		FilterNotEq("state", models.PullDeleted),

     

       
794
       
794
       
+
       
		orm.FilterEq("stack_id", stackId),

     

       
795
       
795
       
+
       
		orm.FilterNotEq("state", models.PullDeleted),

     

       
795
       
796
       
 
       
	)

     

       
796
       
797
       
 
       
	if err != nil {

     

       
797
       
798
       
 
       
		return nil, err

     
···

       
835
       
836
       
 
       
func GetAbandonedPulls(e Execer, stackId string) ([]*models.Pull, error) {

     

       
836
       
837
       
 
       
	pulls, err := GetPulls(

     

       
837
       
838
       
 
       
		e,

     

       
838
       
838
       
-
       
		FilterEq("stack_id", stackId),

     

       
839
       
839
       
-
       
		FilterEq("state", models.PullDeleted),

     

       
839
       
839
       
+
       
		orm.FilterEq("stack_id", stackId),

     

       
840
       
840
       
+
       
		orm.FilterEq("state", models.PullDeleted),

     

       
840
       
841
       
 
       
	)

     

       
841
       
842
       
 
       
	if err != nil {

     

       
842
       
843
       
 
       
		return nil, err

     

···

       
7
       
7
       
 
       
	"time"

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
	"tangled.org/core/appview/models"

     

       
10
       
10
       
+
       
	"tangled.org/core/orm"

     

       
10
       
11
       
 
       
)

     

       
11
       
12
       
 
       


     

       
12
       
13
       
 
       
// this adds to the existing count

     
···

       
20
       
21
       
 
       
	return err

     

       
21
       
22
       
 
       
}

     

       
22
       
23
       
 
       


     

       
23
       
23
       
-
       
func MakePunchcard(e Execer, filters ...filter) (*models.Punchcard, error) {

     

       
24
       
24
       
+
       
func MakePunchcard(e Execer, filters ...orm.Filter) (*models.Punchcard, error) {

     

       
24
       
25
       
 
       
	punchcard := &models.Punchcard{}

     

       
25
       
26
       
 
       
	now := time.Now()

     

       
26
       
27
       
 
       
	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

···

       
8
       
8
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
9
       
9
       
 
       
	"tangled.org/core/api/tangled"

     

       
10
       
10
       
 
       
	"tangled.org/core/appview/models"

     

       
11
       
11
       
+
       
	"tangled.org/core/orm"

     

       
11
       
12
       
 
       
)

     

       
12
       
13
       
 
       


     

       
13
       
14
       
 
       
// ValidateReferenceLinks resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     
···

       
205
       
206
       
 
       
	return err

     

       
206
       
207
       
 
       
}

     

       
207
       
208
       
 
       


     

       
208
       
208
       
-
       
func GetReferencesAll(e Execer, filters ...filter) (map[syntax.ATURI][]syntax.ATURI, error) {

     

       
209
       
209
       
+
       
func GetReferencesAll(e Execer, filters ...orm.Filter) (map[syntax.ATURI][]syntax.ATURI, error) {

     

       
209
       
210
       
 
       
	var (

     

       
210
       
211
       
 
       
		conditions []string

     

       
211
       
212
       
 
       
		args       []any

     
···

       
347
       
348
       
 
       
	if len(aturis) == 0 {

     

       
348
       
349
       
 
       
		return nil, nil

     

       
349
       
350
       
 
       
	}

     

       
350
       
350
       
-
       
	filter := FilterIn("c.at_uri", aturis)

     

       
351
       
351
       
+
       
	filter := orm.FilterIn("c.at_uri", aturis)

     

       
351
       
352
       
 
       
	rows, err := e.Query(

     

       
352
       
353
       
 
       
		fmt.Sprintf(

     

       
353
       
354
       
 
       
			`select r.did, r.name, i.issue_id, c.id, i.title, i.open

     
···

       
427
       
428
       
 
       
	if len(aturis) == 0 {

     

       
428
       
429
       
 
       
		return nil, nil

     

       
429
       
430
       
 
       
	}

     

       
430
       
430
       
-
       
	filter := FilterIn("c.comment_at", aturis)

     

       
431
       
431
       
+
       
	filter := orm.FilterIn("c.comment_at", aturis)

     

       
431
       
432
       
 
       
	rows, err := e.Query(

     

       
432
       
433
       
 
       
		fmt.Sprintf(

     

       
433
       
434
       
 
       
			`select r.did, r.name, p.pull_id, c.id, p.title, p.state

     

···

       
7
       
7
       
 
       
	"time"

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
	"tangled.org/core/appview/models"

     

       
10
       
10
       
+
       
	"tangled.org/core/orm"

     

       
10
       
11
       
 
       
)

     

       
11
       
12
       
 
       


     

       
12
       
12
       
-
       
func GetRegistrations(e Execer, filters ...filter) ([]models.Registration, error) {

     

       
13
       
13
       
+
       
func GetRegistrations(e Execer, filters ...orm.Filter) ([]models.Registration, error) {

     

       
13
       
14
       
 
       
	var registrations []models.Registration

     

       
14
       
15
       
 
       


     

       
15
       
16
       
 
       
	var conditions []string

     
···

       
69
       
70
       
 
       
	return registrations, nil

     

       
70
       
71
       
 
       
}

     

       
71
       
72
       
 
       


     

       
72
       
72
       
-
       
func MarkRegistered(e Execer, filters ...filter) error {

     

       
73
       
73
       
+
       
func MarkRegistered(e Execer, filters ...orm.Filter) error {

     

       
73
       
74
       
 
       
	var conditions []string

     

       
74
       
75
       
 
       
	var args []any

     

       
75
       
76
       
 
       
	for _, filter := range filters {

     
···

       
94
       
95
       
 
       
	return err

     

       
95
       
96
       
 
       
}

     

       
96
       
97
       
 
       


     

       
97
       
97
       
-
       
func DeleteKnot(e Execer, filters ...filter) error {

     

       
98
       
98
       
+
       
func DeleteKnot(e Execer, filters ...orm.Filter) error {

     

       
98
       
99
       
 
       
	var conditions []string

     

       
99
       
100
       
 
       
	var args []any

     

       
100
       
101
       
 
       
	for _, filter := range filters {

     

···

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
13
       
13
       
 
       
	"tangled.org/core/appview/models"

     

       
14
       
14
       
+
       
	"tangled.org/core/orm"

     

       
14
       
15
       
 
       
)

     

       
15
       
16
       
 
       


     

       
16
       
16
       
-
       
func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {

     

       
17
       
17
       
+
       
func GetRepos(e Execer, limit int, filters ...orm.Filter) ([]models.Repo, error) {

     

       
17
       
18
       
 
       
	repoMap := make(map[syntax.ATURI]*models.Repo)

     

       
18
       
19
       
 
       


     

       
19
       
20
       
 
       
	var conditions []string

     
···

       
294
       
295
       
 
       
}

     

       
295
       
296
       
 
       


     

       
296
       
297
       
 
       
// helper to get exactly one repo

     

       
297
       
297
       
-
       
func GetRepo(e Execer, filters ...filter) (*models.Repo, error) {

     

       
298
       
298
       
+
       
func GetRepo(e Execer, filters ...orm.Filter) (*models.Repo, error) {

     

       
298
       
299
       
 
       
	repos, err := GetRepos(e, 0, filters...)

     

       
299
       
300
       
 
       
	if err != nil {

     

       
300
       
301
       
 
       
		return nil, err

     
···

       
311
       
312
       
 
       
	return &repos[0], nil

     

       
312
       
313
       
 
       
}

     

       
313
       
314
       
 
       


     

       
314
       
314
       
-
       
func CountRepos(e Execer, filters ...filter) (int64, error) {

     

       
315
       
315
       
+
       
func CountRepos(e Execer, filters ...orm.Filter) (int64, error) {

     

       
315
       
316
       
 
       
	var conditions []string

     

       
316
       
317
       
 
       
	var args []any

     

       
317
       
318
       
 
       
	for _, filter := range filters {

     
···

       
542
       
543
       
 
       
	return err

     

       
543
       
544
       
 
       
}

     

       
544
       
545
       
 
       


     

       
545
       
545
       
-
       
func UnsubscribeLabel(e Execer, filters ...filter) error {

     

       
546
       
546
       
+
       
func UnsubscribeLabel(e Execer, filters ...orm.Filter) error {

     

       
546
       
547
       
 
       
	var conditions []string

     

       
547
       
548
       
 
       
	var args []any

     

       
548
       
549
       
 
       
	for _, filter := range filters {

     
···

       
560
       
561
       
 
       
	return err

     

       
561
       
562
       
 
       
}

     

       
562
       
563
       
 
       


     

       
563
       
563
       
-
       
func GetRepoLabels(e Execer, filters ...filter) ([]models.RepoLabel, error) {

     

       
564
       
564
       
+
       
func GetRepoLabels(e Execer, filters ...orm.Filter) ([]models.RepoLabel, error) {

     

       
564
       
565
       
 
       
	var conditions []string

     

       
565
       
566
       
 
       
	var args []any

     

       
566
       
567
       
 
       
	for _, filter := range filters {

     

···

       
7
       
7
       
 
       
	"time"

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
	"tangled.org/core/appview/models"

     

       
10
       
10
       
+
       
	"tangled.org/core/orm"

     

       
10
       
11
       
 
       
)

     

       
11
       
12
       
 
       


     

       
12
       
12
       
-
       
func GetSpindles(e Execer, filters ...filter) ([]models.Spindle, error) {

     

       
13
       
13
       
+
       
func GetSpindles(e Execer, filters ...orm.Filter) ([]models.Spindle, error) {

     

       
13
       
14
       
 
       
	var spindles []models.Spindle

     

       
14
       
15
       
 
       


     

       
15
       
16
       
 
       
	var conditions []string

     
···

       
91
       
92
       
 
       
	return err

     

       
92
       
93
       
 
       
}

     

       
93
       
94
       
 
       


     

       
94
       
94
       
-
       
func VerifySpindle(e Execer, filters ...filter) (int64, error) {

     

       
95
       
95
       
+
       
func VerifySpindle(e Execer, filters ...orm.Filter) (int64, error) {

     

       
95
       
96
       
 
       
	var conditions []string

     

       
96
       
97
       
 
       
	var args []any

     

       
97
       
98
       
 
       
	for _, filter := range filters {

     
···

       
114
       
115
       
 
       
	return res.RowsAffected()

     

       
115
       
116
       
 
       
}

     

       
116
       
117
       
 
       


     

       
117
       
117
       
-
       
func DeleteSpindle(e Execer, filters ...filter) error {

     

       
118
       
118
       
+
       
func DeleteSpindle(e Execer, filters ...orm.Filter) error {

     

       
118
       
119
       
 
       
	var conditions []string

     

       
119
       
120
       
 
       
	var args []any

     

       
120
       
121
       
 
       
	for _, filter := range filters {

     
···

       
144
       
145
       
 
       
	return err

     

       
145
       
146
       
 
       
}

     

       
146
       
147
       
 
       


     

       
147
       
147
       
-
       
func RemoveSpindleMember(e Execer, filters ...filter) error {

     

       
148
       
148
       
+
       
func RemoveSpindleMember(e Execer, filters ...orm.Filter) error {

     

       
148
       
149
       
 
       
	var conditions []string

     

       
149
       
150
       
 
       
	var args []any

     

       
150
       
151
       
 
       
	for _, filter := range filters {

     
···

       
163
       
164
       
 
       
	return err

     

       
164
       
165
       
 
       
}

     

       
165
       
166
       
 
       


     

       
166
       
166
       
-
       
func GetSpindleMembers(e Execer, filters ...filter) ([]models.SpindleMember, error) {

     

       
167
       
167
       
+
       
func GetSpindleMembers(e Execer, filters ...orm.Filter) ([]models.SpindleMember, error) {

     

       
167
       
168
       
 
       
	var members []models.SpindleMember

     

       
168
       
169
       
 
       


     

       
169
       
170
       
 
       
	var conditions []string