feat: v1 API + frontend migration

2026-07-03 14:06:33 -04:00
parent ff44db311d
commit c9e4d345b8
212 changed files with 26747 additions and 398 deletions
--- a/database/documents_test.go
+++ b/database/documents_test.go
@@ -4,10 +4,13 @@ import (
 	"context"
 	"fmt"
 	"testing"
+	"time"

 	"github.com/stretchr/testify/suite"

 	"reichard.io/antholume/config"
+	"reichard.io/antholume/pkg/ptr"
+	"reichard.io/antholume/utils"
 )

 type DocumentsTestSuite struct {
@@ -36,12 +39,54 @@ func (suite *DocumentsTestSuite) SetupTest() {
 	suite.NoError(err)
 }

-// DOCUMENT - TODO:
-//   - 󰊕  (q *Queries) GetDocumentProgress
-//   - 󰊕  (q *Queries) GetDocumentWithStats
-//   - 󰊕  (q *Queries) GetDocumentsSize
-//   - 󰊕  (q *Queries) GetDocumentsWithStats
-//   - 󰊕  (q *Queries) GetMissingDocuments
+func (suite *DocumentsTestSuite) seedDocumentStats() {
+	suite.createTestUserAndDevice()
+
+	var err error
+	_, err = suite.dbm.Queries.AddActivity(context.Background(), AddActivityParams{
+		DocumentID:      documentID,
+		DeviceID:        deviceID,
+		UserID:          userID,
+		StartTime:       time.Now().UTC().Format(time.RFC3339),
+		Duration:        60,
+		StartPercentage: 0.10,
+		EndPercentage:   0.20,
+	})
+	suite.Require().NoError(err)
+
+	_, err = suite.dbm.Queries.UpdateProgress(context.Background(), UpdateProgressParams{
+		UserID:     userID,
+		DocumentID: documentID,
+		DeviceID:   deviceID,
+		Percentage: 0.42,
+		Progress:   "/6/2[test]",
+	})
+	suite.Require().NoError(err)
+
+	err = suite.dbm.CacheTempTables(context.Background())
+	suite.Require().NoError(err)
+}
+
+func (suite *DocumentsTestSuite) createTestUserAndDevice() {
+	rawAuthHash, err := utils.GenerateToken(64)
+	suite.Require().NoError(err)
+	authHash := fmt.Sprintf("%x", rawAuthHash)
+
+	_, err = suite.dbm.Queries.CreateUser(context.Background(), CreateUserParams{
+		ID:       userID,
+		Pass:     &userPass,
+		AuthHash: &authHash,
+	})
+	suite.Require().NoError(err)
+
+	_, err = suite.dbm.Queries.UpsertDevice(context.Background(), UpsertDeviceParams{
+		ID:         deviceID,
+		UserID:     userID,
+		DeviceName: deviceName,
+	})
+	suite.Require().NoError(err)
+}
+
 func (suite *DocumentsTestSuite) TestGetDocument() {
 	doc, err := suite.dbm.Queries.GetDocument(context.Background(), documentID)
 	suite.Nil(err, "should have nil err")
@@ -63,6 +108,265 @@ func (suite *DocumentsTestSuite) TestUpsertDocument() {
 	suite.Equal(documentAuthor, *doc.Author, "should have document author")
 }

+func (suite *DocumentsTestSuite) TestGetDocumentProgress() {
+	suite.seedDocumentStats()
+
+	progress, err := suite.dbm.Queries.GetDocumentProgress(context.Background(), GetDocumentProgressParams{
+		UserID:     userID,
+		DocumentID: documentID,
+	})
+
+	suite.NoError(err)
+	suite.Equal(userID, progress.UserID)
+	suite.Equal(documentID, progress.DocumentID)
+	suite.Equal(deviceID, progress.DeviceID)
+	suite.Equal(deviceName, progress.DeviceName)
+	suite.Equal(0.42, progress.Percentage)
+	suite.Equal("/6/2[test]", progress.Progress)
+}
+
+func (suite *DocumentsTestSuite) TestGetDocumentWithStats() {
+	suite.seedDocumentStats()
+
+	doc, err := suite.dbm.GetDocument(context.Background(), documentID, userID)
+
+	suite.NoError(err)
+	suite.Equal(documentID, doc.ID)
+	suite.Equal(documentTitle, *doc.Title)
+	suite.Equal(documentAuthor, *doc.Author)
+	suite.Equal(documentWords, *doc.Words)
+	suite.Equal(float64(42), doc.Percentage)
+	suite.Equal(int64(60), doc.TotalTimeSeconds)
+	suite.Equal(int64(500), doc.Wpm)
+	suite.Equal(int64(6), doc.SecondsPerPercent)
+}
+
+func (suite *DocumentsTestSuite) TestGetDocumentsSize() {
+	count, err := suite.dbm.Queries.GetDocumentsSize(context.Background(), nil)
+
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsSize(context.Background(), "%testTitle%")
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsSize(context.Background(), "%missing%")
+	suite.NoError(err)
+	suite.Equal(int64(0), count)
+}
+
+func (suite *DocumentsTestSuite) TestGetDocumentsWithStatsCount() {
+	count, err := suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		Query: ptr.Of("%testTitle%"),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		Query: ptr.Of("%testAuthor%"),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		Query: ptr.Of("%missing%"),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(0), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		ID: ptr.Of(documentID),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		ID: ptr.Of("missing-id"),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(0), count)
+
+	_, err = suite.dbm.Queries.DeleteDocument(context.Background(), documentID)
+	suite.Require().NoError(err)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		Deleted: ptr.Of(false),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(0), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		Deleted: ptr.Of(true),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+
+	count, err = suite.dbm.Queries.GetDocumentsWithStatsCount(context.Background(), GetDocumentsWithStatsCountParams{
+		ID:      ptr.Of(documentID),
+		Deleted: ptr.Of(true),
+	})
+	suite.NoError(err)
+	suite.Equal(int64(1), count)
+}
+
+func (suite *DocumentsTestSuite) TestGetDocumentsWithStats() {
+	suite.seedDocumentStats()
+
+	rows, err := suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID:  userID,
+		Deleted: ptr.Of(false),
+		Query:   ptr.Of("%testTitle%"),
+		Offset:  0,
+		Limit:   10,
+	})
+
+	suite.NoError(err)
+	suite.Len(rows, 1)
+	suite.Equal(documentID, rows[0].ID)
+	suite.Equal(documentTitle, *rows[0].Title)
+	suite.Equal(float64(42), rows[0].Percentage)
+	suite.Equal(int64(60), rows[0].TotalTimeSeconds)
+
+	_, err = suite.dbm.Queries.DeleteDocument(context.Background(), documentID)
+	suite.NoError(err)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID:  userID,
+		Deleted: ptr.Of(false),
+		Offset:  0,
+		Limit:   10,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 0)
+}
+
+func (suite *DocumentsTestSuite) TestGetDocumentsWithStatsFilters() {
+	suite.createTestUserAndDevice()
+
+	otherDocID := "testDocument2"
+	otherTitle := "otherTitle"
+	otherAuthor := "otherAuthor"
+	otherWords := int64(3000)
+	_, err := suite.dbm.Queries.UpsertDocument(context.Background(), UpsertDocumentParams{
+		ID:     otherDocID,
+		Title:  &otherTitle,
+		Author: &otherAuthor,
+		Words:  &otherWords,
+	})
+	suite.Require().NoError(err)
+
+	_, err = suite.dbm.Queries.AddActivity(context.Background(), AddActivityParams{
+		DocumentID:      documentID,
+		DeviceID:        deviceID,
+		UserID:          userID,
+		StartTime:       time.Now().Add(-2 * time.Hour).UTC().Format(time.RFC3339),
+		Duration:        60,
+		StartPercentage: 0.10,
+		EndPercentage:   0.20,
+	})
+	suite.Require().NoError(err)
+
+	_, err = suite.dbm.Queries.UpdateProgress(context.Background(), UpdateProgressParams{
+		UserID:     userID,
+		DocumentID: documentID,
+		DeviceID:   deviceID,
+		Percentage: 0.42,
+		Progress:   "/6/2[test]",
+	})
+	suite.Require().NoError(err)
+
+	_, err = suite.dbm.Queries.AddActivity(context.Background(), AddActivityParams{
+		DocumentID:      otherDocID,
+		DeviceID:        deviceID,
+		UserID:          userID,
+		StartTime:       time.Now().Add(-1 * time.Hour).UTC().Format(time.RFC3339),
+		Duration:        30,
+		StartPercentage: 0.20,
+		EndPercentage:   0.30,
+	})
+	suite.Require().NoError(err)
+
+	err = suite.dbm.CacheTempTables(context.Background())
+	suite.Require().NoError(err)
+
+	rows, err := suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID: userID,
+		ID:     ptr.Of(documentID),
+		Offset: 0,
+		Limit:  10,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 1)
+	suite.Equal(documentID, rows[0].ID)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID: userID,
+		Query:  ptr.Of("%otherAuthor%"),
+		Offset: 0,
+		Limit:  10,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 1)
+	suite.Equal(otherDocID, rows[0].ID)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID: userID,
+		Query:  ptr.Of("%does-not-match%"),
+		Offset: 0,
+		Limit:  10,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 0)
+
+	_, err = suite.dbm.Queries.DeleteDocument(context.Background(), otherDocID)
+	suite.Require().NoError(err)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID:  userID,
+		Deleted: ptr.Of(true),
+		Offset:  0,
+		Limit:   10,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 1)
+	suite.Equal(otherDocID, rows[0].ID)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID: userID,
+		Offset: 0,
+		Limit:  10,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 2)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID: userID,
+		Offset: 0,
+		Limit:  1,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 1)
+	suite.Equal(otherDocID, rows[0].ID)
+
+	rows, err = suite.dbm.Queries.GetDocumentsWithStats(context.Background(), GetDocumentsWithStatsParams{
+		UserID: userID,
+		Offset: 1,
+		Limit:  1,
+	})
+	suite.NoError(err)
+	suite.Len(rows, 1)
+	suite.Equal(documentID, rows[0].ID)
+}
+
 func (suite *DocumentsTestSuite) TestDeleteDocument() {
 	changed, err := suite.dbm.Queries.DeleteDocument(context.Background(), documentID)
 	suite.Nil(err, "should have nil err")
@@ -85,7 +389,10 @@ func (suite *DocumentsTestSuite) TestGetDeletedDocuments() {

 // TODO - Convert GetWantedDocuments -> (sqlc.slice('document_ids'));
 func (suite *DocumentsTestSuite) TestGetWantedDocuments() {
-	wantedDocs, err := suite.dbm.Queries.GetWantedDocuments(context.Background(), fmt.Sprintf("[\"%s\"]", documentID))
+	wantedDocs, err := suite.dbm.Queries.GetWantedDocuments(context.Background(), GetWantedDocumentsParams{
+		JsonEach:    fmt.Sprintf("[\"%s\"]", documentID),
+		DocumentIds: fmt.Sprintf("[\"%s\"]", documentID),
+	})
 	suite.Nil(err, "should have nil err")
 	suite.Len(wantedDocs, 1, "should have one wanted document")
 }