feat: support s3 for blog pages

refactor: make blog client an interface
feat: claude.md

3 files changed, 300 insertions, 0 deletions

diff --git a/internal/blog/b2.go b/internal/blog/b2.go
new file mode 100644
index 0000000..0caa0ba
--- /dev/null
+++ b/internal/blog/b2.go
@@ -0,0 +1,133 @@
+package blog
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/Backblaze/blazer/b2"
+	"github.com/SayaAndy/saya-today-web/config"
+	"github.com/SayaAndy/saya-today-web/internal/frontmatter"
+)
+
+type B2Client struct {
+	prefix string
+	bucket *b2.Bucket
+	b2cl   *b2.Client
+}
+
+func NewB2Client(cfg *config.StorageConfig) (Client, error) {
+	if cfg.Type != "b2" {
+		return nil, fmt.Errorf("invalid storage type for B2InputClient")
+	}
+	b2cfg := cfg.Config.(*config.B2Config)
+
+	b2cl, err := b2.NewClient(context.Background(), b2cfg.KeyID, b2cfg.ApplicationKey)
+	if err != nil {
+		return nil, err
+	}
+
+	bucket, err := b2cl.Bucket(context.Background(), b2cfg.BucketName)
+	if err != nil {
+		return nil, err
+	}
+
+	return &B2Client{b2cl: b2cl, bucket: bucket, prefix: b2cfg.Prefix}, nil
+}
+
+func (c *B2Client) Scan(prefix string) ([]*Page, error) {
+	filePaths := []*Page{}
+
+	iter := c.bucket.List(context.Background(), b2.ListPrefix(c.prefix+prefix))
+
+	for iter.Next() {
+		obj := iter.Object()
+		if obj == nil {
+			return nil, fmt.Errorf("failed to reference object in B2 bucket")
+		}
+
+		attrs, err := obj.Attrs(context.Background())
+		if err != nil {
+			return nil, fmt.Errorf("get attributes for object: %w", err)
+		}
+
+		if attrs.Status != b2.Uploaded {
+			continue
+		}
+
+		if !strings.Contains(attrs.ContentType, "text/markdown") {
+			continue
+		}
+
+		if _, ok := attrs.Info["title"]; !ok {
+			continue
+		}
+
+		publishedTime, err := time.Parse(time.RFC3339, attrs.Info["published-time"])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse published time metadata field: %w", err)
+		}
+
+		linkParts := strings.Split(obj.Name(), "/")
+		nameParts := strings.Split(linkParts[len(linkParts)-1], ".")
+		fileName := strings.Join(nameParts[:len(linkParts)-1], ".")
+
+		tags := strings.Split(attrs.Info["tags"], ",")
+		slices.Sort(tags)
+
+		lang, _ := strings.CutPrefix(linkParts[0], c.prefix)
+
+		filePaths = append(filePaths, &Page{
+			Link:         obj.Name(),
+			FileName:     fileName,
+			Lang:         lang,
+			ModifiedTime: attrs.LastModified,
+			Metadata: &frontmatter.Metadata{
+				Title:            attrs.Info["title"],
+				ShortDescription: attrs.Info["short-description"],
+				ActionDate:       attrs.Info["action-date"],
+				PublishedTime:    publishedTime,
+				Thumbnail:        attrs.Info["thumbnail"],
+				Tags:             tags,
+				Geolocation:      attrs.Info["geolocation"],
+			},
+		})
+	}
+
+	if err := iter.Err(); err != nil {
+		return nil, fmt.Errorf("iterate over B2 objects: %w", err)
+	}
+
+	return filePaths, nil
+}
+
+func (c *B2Client) ReadAll(path string) ([]byte, error) {
+	obj := c.bucket.Object(c.prefix + path)
+	if obj == nil {
+		return nil, fmt.Errorf("failed to reference object in B2 bucket")
+	}
+	attrs, err := obj.Attrs(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("error getting attributes of an object: %w", err)
+	}
+
+	content := make([]byte, attrs.Size)
+	reader := obj.NewReader(context.Background())
+
+	if _, err = reader.Read(content); err != nil {
+		return nil, fmt.Errorf("failed to read file content: %w", err)
+	}
+
+	return content, nil
+}
+
+func (c *B2Client) ReadFrontmatter(path string) (metadata *frontmatter.Metadata, markdown []byte, err error) {
+	contentBytes, err := c.ReadAll(path)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to read file for frontmatter parsing: %w", err)
+	}
+
+	return frontmatter.ParseFrontmatter(contentBytes)
+}
diff --git a/internal/blog/client.go b/internal/blog/client.go
new file mode 100644
index 0000000..56bbee4
--- /dev/null
+++ b/internal/blog/client.go
@@ -0,0 +1,27 @@
+package blog
+
+import (
+	"time"
+
+	"github.com/SayaAndy/saya-today-web/config"
+	"github.com/SayaAndy/saya-today-web/internal/frontmatter"
+)
+
+type Page struct {
+	Link         string
+	FileName     string
+	Lang         string
+	ModifiedTime time.Time
+	Metadata     *frontmatter.Metadata
+}
+
+type Client interface {
+	Scan(prefix string) ([]*Page, error)
+	ReadAll(path string) ([]byte, error)
+	ReadFrontmatter(path string) (metadata *frontmatter.Metadata, markdown []byte, err error)
+}
+
+var NewClientMap = map[string]func(*config.StorageConfig) (Client, error){
+	"b2": NewB2Client,
+	"s3": NewS3Client,
+}
diff --git a/internal/blog/s3.go b/internal/blog/s3.go
new file mode 100644
index 0000000..de4eb3a
--- /dev/null
+++ b/internal/blog/s3.go
@@ -0,0 +1,140 @@
+package blog
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SayaAndy/saya-today-web/config"
+	"github.com/SayaAndy/saya-today-web/internal/frontmatter"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+)
+
+type S3Client struct {
+	prefix     string
+	bucketName string
+	s3cl       *s3.Client
+}
+
+func NewS3Client(cfg *config.StorageConfig) (Client, error) {
+	if cfg.Type != "s3" {
+		return nil, fmt.Errorf("invalid storage type for S3Client")
+	}
+	s3cfg := cfg.Config.(*config.S3Config)
+
+	s3cl := s3.New(s3.Options{
+		Region:       s3cfg.Region,
+		BaseEndpoint: aws.String(s3cfg.Endpoint),
+		Credentials:  credentials.NewStaticCredentialsProvider(s3cfg.AccessKeyID, s3cfg.SecretAccessKey, ""),
+	})
+
+	return &S3Client{s3cfg.Prefix, s3cfg.BucketName, s3cl}, nil
+}
+
+func (c *S3Client) Scan(prefix string) ([]*Page, error) {
+	pages := []*Page{}
+
+	fullPrefix := c.prefix + prefix
+	input := &s3.ListObjectsV2Input{
+		Bucket: aws.String(c.bucketName),
+		Prefix: aws.String(fullPrefix),
+	}
+
+	paginator := s3.NewListObjectsV2Paginator(c.s3cl, input)
+
+	for paginator.HasMorePages() {
+		output, err := paginator.NextPage(context.Background())
+		if err != nil {
+			return nil, fmt.Errorf("list S3 objects: %w", err)
+		}
+
+		for _, obj := range output.Contents {
+			key := aws.ToString(obj.Key)
+
+			if !strings.HasSuffix(key, ".md") {
+				continue
+			}
+
+			head, err := c.s3cl.HeadObject(context.Background(), &s3.HeadObjectInput{
+				Bucket: aws.String(c.bucketName),
+				Key:    aws.String(key),
+			})
+			if err != nil {
+				return nil, fmt.Errorf("head S3 object %s: %w", key, err)
+			}
+
+			if head.ContentType == nil || !strings.Contains(*head.ContentType, "text/markdown") {
+				continue
+			}
+
+			meta := head.Metadata
+			if meta["title"] == "" {
+				continue
+			}
+
+			publishedTime, err := time.Parse(time.RFC3339, meta["published-time"])
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse published time metadata field: %w", err)
+			}
+
+			linkParts := strings.Split(key, "/")
+			nameParts := strings.Split(linkParts[len(linkParts)-1], ".")
+			fileName := strings.Join(nameParts[:len(nameParts)-1], ".")
+
+			tags := strings.Split(meta["tags"], ",")
+			slices.Sort(tags)
+
+			lang, _ := strings.CutPrefix(linkParts[0], c.prefix)
+
+			pages = append(pages, &Page{
+				Link:         key,
+				FileName:     fileName,
+				Lang:         lang,
+				ModifiedTime: aws.ToTime(obj.LastModified),
+				Metadata: &frontmatter.Metadata{
+					Title:            meta["title"],
+					ShortDescription: meta["short-description"],
+					ActionDate:       meta["action-date"],
+					PublishedTime:    publishedTime,
+					Thumbnail:        meta["thumbnail"],
+					Tags:             tags,
+					Geolocation:      meta["geolocation"],
+				},
+			})
+		}
+	}
+
+	return pages, nil
+}
+
+func (c *S3Client) ReadAll(path string) ([]byte, error) {
+	output, err := c.s3cl.GetObject(context.Background(), &s3.GetObjectInput{
+		Bucket: aws.String(c.bucketName),
+		Key:    aws.String(c.prefix + path),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("get S3 object: %w", err)
+	}
+	defer output.Body.Close()
+
+	content, err := io.ReadAll(output.Body)
+	if err != nil {
+		return nil, fmt.Errorf("read S3 object body: %w", err)
+	}
+
+	return content, nil
+}
+
+func (c *S3Client) ReadFrontmatter(path string) (metadata *frontmatter.Metadata, markdown []byte, err error) {
+	contentBytes, err := c.ReadAll(path)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to read file for frontmatter parsing: %w", err)
+	}
+
+	return frontmatter.ParseFrontmatter(contentBytes)
+}