document_versions.sql.go

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

package database

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const createDocument = `-- name: CreateDocument :one

INSERT INTO documents (name, current_version)
VALUES ($1, 1)
RETURNING id, name, current_version, created_at
`

// Document Queries
func (q *Queries) CreateDocument(ctx context.Context, name string) (Document, error) {
	row := q.db.QueryRow(ctx, createDocument, name)
	var i Document
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CurrentVersion,
		&i.CreatedAt,
	)
	return i, err
}

const createDocumentVersion = `-- name: CreateDocumentVersion :one

INSERT INTO document_versions (document_id, version, patch, inverted_patch)
VALUES ($1, $2, $3, $4)
RETURNING document_id, version, patch, inverted_patch, created_at
`

type CreateDocumentVersionParams struct {
	DocumentID    pgtype.UUID `json:"document_id"`
	Version       int32       `json:"version"`
	Patch         []byte      `json:"patch"`
	InvertedPatch []byte      `json:"inverted_patch"`
}

// Document Version Queries
func (q *Queries) CreateDocumentVersion(ctx context.Context, arg CreateDocumentVersionParams) (DocumentVersion, error) {
	row := q.db.QueryRow(ctx, createDocumentVersion,
		arg.DocumentID,
		arg.Version,
		arg.Patch,
		arg.InvertedPatch,
	)
	var i DocumentVersion
	err := row.Scan(
		&i.DocumentID,
		&i.Version,
		&i.Patch,
		&i.InvertedPatch,
		&i.CreatedAt,
	)
	return i, err
}

const deleteDocument = `-- name: DeleteDocument :exec
DELETE FROM documents
WHERE id = $1
`

func (q *Queries) DeleteDocument(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteDocument, id)
	return err
}

const getDocument = `-- name: GetDocument :one
SELECT id, name, current_version, created_at
FROM documents
WHERE id = $1
`

func (q *Queries) GetDocument(ctx context.Context, id pgtype.UUID) (Document, error) {
	row := q.db.QueryRow(ctx, getDocument, id)
	var i Document
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CurrentVersion,
		&i.CreatedAt,
	)
	return i, err
}

const getDocumentVersion = `-- name: GetDocumentVersion :one
SELECT document_id, version, patch, inverted_patch, created_at
FROM document_versions
WHERE document_id = $1 AND version = $2
`

type GetDocumentVersionParams struct {
	DocumentID pgtype.UUID `json:"document_id"`
	Version    int32       `json:"version"`
}

// Retrieve a specific version record for a document
// Parameters: document_id (UUID), version (INT)
// Returns: document_id, version, patch, inverted_patch, created_at
func (q *Queries) GetDocumentVersion(ctx context.Context, arg GetDocumentVersionParams) (DocumentVersion, error) {
	row := q.db.QueryRow(ctx, getDocumentVersion, arg.DocumentID, arg.Version)
	var i DocumentVersion
	err := row.Scan(
		&i.DocumentID,
		&i.Version,
		&i.Patch,
		&i.InvertedPatch,
		&i.CreatedAt,
	)
	return i, err
}

const getDocumentVersions = `-- name: GetDocumentVersions :many
SELECT document_id, version, patch, inverted_patch, created_at
FROM document_versions
WHERE document_id = $1
ORDER BY version ASC
`

// Retrieve all versions for a document, ordered by version ascending
// This is needed to reconstruct the document at any version
// Parameters: document_id (UUID)
// Returns: all columns, ordered by version ASC
func (q *Queries) GetDocumentVersions(ctx context.Context, documentID pgtype.UUID) ([]DocumentVersion, error) {
	rows, err := q.db.Query(ctx, getDocumentVersions, documentID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []DocumentVersion{}
	for rows.Next() {
		var i DocumentVersion
		if err := rows.Scan(
			&i.DocumentID,
			&i.Version,
			&i.Patch,
			&i.InvertedPatch,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getLatestVersion = `-- name: GetLatestVersion :one
SELECT MAX(version) as version
FROM document_versions
WHERE document_id = $1
`

// Get the latest version number for a document
// Parameters: document_id (UUID)
// Returns: the maximum version number
// Hint: Use MAX() aggregate function
func (q *Queries) GetLatestVersion(ctx context.Context, documentID pgtype.UUID) (interface{}, error) {
	row := q.db.QueryRow(ctx, getLatestVersion, documentID)
	var version interface{}
	err := row.Scan(&version)
	return version, err
}

const getVersionHistory = `-- name: GetVersionHistory :many
SELECT version, created_at
FROM document_versions
WHERE document_id = $1
ORDER BY version DESC
`

type GetVersionHistoryRow struct {
	Version   int32            `json:"version"`
	CreatedAt pgtype.Timestamp `json:"created_at"`
}

// Retrieve version metadata (version number and created_at) for displaying history
// Parameters: document_id (UUID)
// Returns: version, created_at, ordered by version DESC (newest first)
func (q *Queries) GetVersionHistory(ctx context.Context, documentID pgtype.UUID) ([]GetVersionHistoryRow, error) {
	rows, err := q.db.Query(ctx, getVersionHistory, documentID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetVersionHistoryRow{}
	for rows.Next() {
		var i GetVersionHistoryRow
		if err := rows.Scan(&i.Version, &i.CreatedAt); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateDocumentVersion = `-- name: UpdateDocumentVersion :exec
UPDATE documents
SET current_version = $2
WHERE id = $1
`

type UpdateDocumentVersionParams struct {
	ID             pgtype.UUID `json:"id"`
	CurrentVersion int32       `json:"current_version"`
}

func (q *Queries) UpdateDocumentVersion(ctx context.Context, arg UpdateDocumentVersionParams) error {
	_, err := q.db.Exec(ctx, updateDocumentVersion, arg.ID, arg.CurrentVersion)
	return err
}