insertr/internal/db/sqlite/versions.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: versions.sql

package sqlite

import (
	"context"
	"database/sql"
)

const createContentVersion = `-- name: CreateContentVersion :exec
INSERT INTO content_versions (content_id, site_id, html_content, original_template, type, created_by)
VALUES (?1, ?2, ?3, ?4, ?5, ?6)
`

type CreateContentVersionParams struct {
	ContentID        string         `json:"content_id"`
	SiteID           string         `json:"site_id"`
	HtmlContent      string         `json:"html_content"`
	OriginalTemplate sql.NullString `json:"original_template"`
	Type             string         `json:"type"`
	CreatedBy        string         `json:"created_by"`
}

func (q *Queries) CreateContentVersion(ctx context.Context, arg CreateContentVersionParams) error {
	_, err := q.db.ExecContext(ctx, createContentVersion,
		arg.ContentID,
		arg.SiteID,
		arg.HtmlContent,
		arg.OriginalTemplate,
		arg.Type,
		arg.CreatedBy,
	)
	return err
}

const deleteOldVersions = `-- name: DeleteOldVersions :exec
DELETE FROM content_versions 
WHERE created_at < ?1 AND site_id = ?2
`

type DeleteOldVersionsParams struct {
	CreatedBefore int64  `json:"created_before"`
	SiteID        string `json:"site_id"`
}

func (q *Queries) DeleteOldVersions(ctx context.Context, arg DeleteOldVersionsParams) error {
	_, err := q.db.ExecContext(ctx, deleteOldVersions, arg.CreatedBefore, arg.SiteID)
	return err
}

const getAllVersionsForSite = `-- name: GetAllVersionsForSite :many
SELECT 
    cv.version_id, cv.content_id, cv.site_id, cv.html_content, cv.original_template, cv.type, cv.created_at, cv.created_by,
    c.html_content as current_html_content
FROM content_versions cv
LEFT JOIN content c ON cv.content_id = c.id AND cv.site_id = c.site_id
WHERE cv.site_id = ?1
ORDER BY cv.created_at DESC
LIMIT ?2
`

type GetAllVersionsForSiteParams struct {
	SiteID     string `json:"site_id"`
	LimitCount int64  `json:"limit_count"`
}

type GetAllVersionsForSiteRow struct {
	VersionID          int64          `json:"version_id"`
	ContentID          string         `json:"content_id"`
	SiteID             string         `json:"site_id"`
	HtmlContent        string         `json:"html_content"`
	OriginalTemplate   sql.NullString `json:"original_template"`
	Type               string         `json:"type"`
	CreatedAt          int64          `json:"created_at"`
	CreatedBy          string         `json:"created_by"`
	CurrentHtmlContent sql.NullString `json:"current_html_content"`
}

func (q *Queries) GetAllVersionsForSite(ctx context.Context, arg GetAllVersionsForSiteParams) ([]GetAllVersionsForSiteRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllVersionsForSite, arg.SiteID, arg.LimitCount)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllVersionsForSiteRow
	for rows.Next() {
		var i GetAllVersionsForSiteRow
		if err := rows.Scan(
			&i.VersionID,
			&i.ContentID,
			&i.SiteID,
			&i.HtmlContent,
			&i.OriginalTemplate,
			&i.Type,
			&i.CreatedAt,
			&i.CreatedBy,
			&i.CurrentHtmlContent,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getContentVersion = `-- name: GetContentVersion :one
SELECT version_id, content_id, site_id, html_content, original_template, type, created_at, created_by
FROM content_versions
WHERE version_id = ?1
`

func (q *Queries) GetContentVersion(ctx context.Context, versionID int64) (ContentVersion, error) {
	row := q.db.QueryRowContext(ctx, getContentVersion, versionID)
	var i ContentVersion
	err := row.Scan(
		&i.VersionID,
		&i.ContentID,
		&i.SiteID,
		&i.HtmlContent,
		&i.OriginalTemplate,
		&i.Type,
		&i.CreatedAt,
		&i.CreatedBy,
	)
	return i, err
}

const getContentVersionHistory = `-- name: GetContentVersionHistory :many
SELECT version_id, content_id, site_id, html_content, original_template, type, created_at, created_by
FROM content_versions
WHERE content_id = ?1 AND site_id = ?2
ORDER BY created_at DESC
LIMIT ?3
`

type GetContentVersionHistoryParams struct {
	ContentID  string `json:"content_id"`
	SiteID     string `json:"site_id"`
	LimitCount int64  `json:"limit_count"`
}

func (q *Queries) GetContentVersionHistory(ctx context.Context, arg GetContentVersionHistoryParams) ([]ContentVersion, error) {
	rows, err := q.db.QueryContext(ctx, getContentVersionHistory, arg.ContentID, arg.SiteID, arg.LimitCount)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ContentVersion
	for rows.Next() {
		var i ContentVersion
		if err := rows.Scan(
			&i.VersionID,
			&i.ContentID,
			&i.SiteID,
			&i.HtmlContent,
			&i.OriginalTemplate,
			&i.Type,
			&i.CreatedAt,
			&i.CreatedBy,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}