weiro/services/publisher/service.go

package publisher

import (
	"context"
	"io"
	"io/fs"
	"iter"
	"log"
	"os"
	"time"

	"emperror.dev/errors"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
	"github.com/netlify/open-api/v2/go/porcelain"
	netlify_ctx "github.com/netlify/open-api/v2/go/porcelain/context"
	"lmika.dev/lmika/weiro/layouts/simplecss"
	"lmika.dev/lmika/weiro/models"
	"lmika.dev/lmika/weiro/models/pubmodel"
	"lmika.dev/lmika/weiro/providers/db"
	"lmika.dev/lmika/weiro/providers/sitebuilder"
	"lmika.dev/lmika/weiro/providers/siteexporter"
	"lmika.dev/lmika/weiro/providers/uploadfiles"
)

type Publisher struct {
	db *db.Provider
	up *uploadfiles.Provider
}

func New(db *db.Provider, up *uploadfiles.Provider) *Publisher {
	return &Publisher{
		db: db,
		up: up,
	}
}

func (p *Publisher) Publish(ctx context.Context, site models.Site) error {
	targets, err := p.db.SelectPublishTargetsOfSite(ctx, site.ID)
	if err != nil {
		return err
	}

	// Fetch all uploads of site
	uploads, err := p.db.SelectUploadsOfSite(ctx, site.ID)
	if err != nil {
		return err
	}

	// Fetch categories with counts
	cats, err := p.db.SelectCategoriesOfSite(ctx, site.ID)
	if err != nil {
		return err
	}
	var catsWithCounts []models.CategoryWithCount
	for _, cat := range cats {
		count, err := p.db.CountPostsOfCategory(ctx, cat.ID)
		if err != nil {
			return err
		}
		catsWithCounts = append(catsWithCounts, models.CategoryWithCount{
			Category:         *cat,
			PostCount:        int(count),
			DescriptionBrief: models.BriefDescription(cat.Description),
		})
	}

	// Fetch pages
	sitePages, err := p.db.SelectPagesOfSite(ctx, site.ID)
	if err != nil {
		return err
	}

	for _, target := range targets {
		if !target.Enabled {
			continue
		}

		pubSite := pubmodel.Site{
			Site: site,
			PostIter: func(ctx context.Context) iter.Seq[models.Maybe[*models.Post]] {
				return p.postIter(ctx, site.ID)
			},
			BaseURL:    target.BaseURL,
			Uploads:    uploads,
			Categories: catsWithCounts,
			PostIterByCategory: func(ctx context.Context, categoryID int64) iter.Seq[models.Maybe[*models.Post]] {
				return p.postIterByCategory(ctx, categoryID)
			},
			CategoriesOfPost: func(ctx context.Context, postID int64) ([]*models.Category, error) {
				return p.db.SelectCategoriesOfPost(ctx, postID)
			},
			Pages: sitePages,
			OpenUpload: func(u models.Upload) (io.ReadCloser, error) {
				return p.up.OpenUpload(site, u)
			},
		}

		if err := p.publishSite(ctx, pubSite, target); err != nil {
			return err
		}
	}

	return nil
}

func (p *Publisher) publishSite(ctx context.Context, pubSite pubmodel.Site, target models.SitePublishTarget) error {
	renderTZ, err := time.LoadLocation(pubSite.Timezone)
	if err != nil {
		renderTZ = time.UTC
	}

	templateFS, err := fs.Sub(simplecss.FS, "templates")
	if err != nil {
		return err
	}

	staticFS, err := fs.Sub(simplecss.FS, "static")
	if err != nil {
		return err
	}

	sb, err := sitebuilder.New(pubSite, sitebuilder.Options{
		BasePosts:   "/posts",
		BaseUploads: "/uploads",
		BaseStatic:  "/static",
		TemplatesFS: templateFS,
		StaticFS:    staticFS,
		FeedItems:   30,
		RenderTZ:    renderTZ,
	})
	if err != nil {
		return err
	}

	switch target.TargetType {
	case "export":
		exporter := siteexporter.New(pubSite.Site, target.BaseURL, target.TargetRef)
		if err := exporter.WriteSiteYAML(); err != nil {
			return err
		}
		for mp := range pubSite.PostIter(ctx) {
			p, err := mp.Get()
			if err != nil {
				return err
			}
			if err := exporter.WritePost(p); err != nil {
				return err
			}
		}
		return nil
	case "localfs":
		log.Printf("Building site at %s", target.TargetRef)
		return sb.BuildSite(target.TargetRef)
	case "netlify":
		return func() error {
			tmpDir, err := os.MkdirTemp("", "weiro-publish")
			if err != nil {
				return err
			}
			defer os.RemoveAll(tmpDir)

			if err := sb.BuildSite(tmpDir); err != nil {
				return err
			}

			ctx = netlify_ctx.WithAuthInfo(ctx, runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error {
				return r.SetHeaderParam("Authorization", "Bearer "+target.TargetKey)
			}))

			client := porcelain.Default
			_, err = client.DeploySite(ctx, porcelain.DeployOptions{
				SiteID: target.TargetRef,
				Dir:    tmpDir,
			})
			return err
		}()
	}

	return errors.New("unknown target type")
}