endpoints.sql.go

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

package database

import (
	"context"
)

const countEndpointsByCollection = `-- name: CountEndpointsByCollection :one
SELECT COUNT(*) FROM endpoints
WHERE collection_id = ?
`

func (q *Queries) CountEndpointsByCollection(ctx context.Context, collectionID int64) (int64, error) {
	row := q.db.QueryRowContext(ctx, countEndpointsByCollection, collectionID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createEndpoint = `-- name: CreateEndpoint :one
INSERT INTO endpoints (
    collection_id,
    name,
    method,
    url,
    headers,
    query_params,
    request_body
) VALUES (
    ?, ?, ?, ?, ?, ?, ?
)
RETURNING id, collection_id, name, method, url, headers, query_params, request_body, created_at, updated_at
`

type CreateEndpointParams struct {
	CollectionID int64  `db:"collection_id" json:"collection_id"`
	Name         string `db:"name" json:"name"`
	Method       string `db:"method" json:"method"`
	Url          string `db:"url" json:"url"`
	Headers      string `db:"headers" json:"headers"`
	QueryParams  string `db:"query_params" json:"query_params"`
	RequestBody  string `db:"request_body" json:"request_body"`
}

func (q *Queries) CreateEndpoint(ctx context.Context, arg CreateEndpointParams) (Endpoint, error) {
	row := q.db.QueryRowContext(ctx, createEndpoint,
		arg.CollectionID,
		arg.Name,
		arg.Method,
		arg.Url,
		arg.Headers,
		arg.QueryParams,
		arg.RequestBody,
	)
	var i Endpoint
	err := row.Scan(
		&i.ID,
		&i.CollectionID,
		&i.Name,
		&i.Method,
		&i.Url,
		&i.Headers,
		&i.QueryParams,
		&i.RequestBody,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteEndpoint = `-- name: DeleteEndpoint :exec
DELETE FROM endpoints
WHERE id = ?
`

func (q *Queries) DeleteEndpoint(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteEndpoint, id)
	return err
}

const getEndpoint = `-- name: GetEndpoint :one
SELECT id, collection_id, name, method, url, headers, query_params, request_body, created_at, updated_at FROM endpoints
WHERE id = ? LIMIT 1
`

func (q *Queries) GetEndpoint(ctx context.Context, id int64) (Endpoint, error) {
	row := q.db.QueryRowContext(ctx, getEndpoint, id)
	var i Endpoint
	err := row.Scan(
		&i.ID,
		&i.CollectionID,
		&i.Name,
		&i.Method,
		&i.Url,
		&i.Headers,
		&i.QueryParams,
		&i.RequestBody,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getEndpointCountsByCollections = `-- name: GetEndpointCountsByCollections :many
SELECT collection_id, COUNT(*) as count
FROM endpoints
GROUP BY collection_id
`

type GetEndpointCountsByCollectionsRow struct {
	CollectionID int64 `db:"collection_id" json:"collection_id"`
	Count        int64 `db:"count" json:"count"`
}

func (q *Queries) GetEndpointCountsByCollections(ctx context.Context) ([]GetEndpointCountsByCollectionsRow, error) {
	rows, err := q.db.QueryContext(ctx, getEndpointCountsByCollections)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetEndpointCountsByCollectionsRow
	for rows.Next() {
		var i GetEndpointCountsByCollectionsRow
		if err := rows.Scan(&i.CollectionID, &i.Count); 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 listEndpointsByCollection = `-- name: ListEndpointsByCollection :many
SELECT id, collection_id, name, method, url, headers, query_params, request_body, created_at, updated_at FROM endpoints
WHERE collection_id = ?
ORDER BY created_at DESC
`

func (q *Queries) ListEndpointsByCollection(ctx context.Context, collectionID int64) ([]Endpoint, error) {
	rows, err := q.db.QueryContext(ctx, listEndpointsByCollection, collectionID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Endpoint
	for rows.Next() {
		var i Endpoint
		if err := rows.Scan(
			&i.ID,
			&i.CollectionID,
			&i.Name,
			&i.Method,
			&i.Url,
			&i.Headers,
			&i.QueryParams,
			&i.RequestBody,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 listEndpointsPaginated = `-- name: ListEndpointsPaginated :many
SELECT id, collection_id, name, method, url, headers, query_params, request_body, created_at, updated_at FROM endpoints
WHERE collection_id = ?
ORDER BY name
LIMIT ? OFFSET ?
`

type ListEndpointsPaginatedParams struct {
	CollectionID int64 `db:"collection_id" json:"collection_id"`
	Limit        int64 `db:"limit" json:"limit"`
	Offset       int64 `db:"offset" json:"offset"`
}

func (q *Queries) ListEndpointsPaginated(ctx context.Context, arg ListEndpointsPaginatedParams) ([]Endpoint, error) {
	rows, err := q.db.QueryContext(ctx, listEndpointsPaginated, arg.CollectionID, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Endpoint
	for rows.Next() {
		var i Endpoint
		if err := rows.Scan(
			&i.ID,
			&i.CollectionID,
			&i.Name,
			&i.Method,
			&i.Url,
			&i.Headers,
			&i.QueryParams,
			&i.RequestBody,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 updateEndpoint = `-- name: UpdateEndpoint :one
UPDATE endpoints
SET
    name = ?,
    method = ?,
    url = ?,
    headers = ?,
    query_params = ?,
    request_body = ?
WHERE
    id = ?
RETURNING id, collection_id, name, method, url, headers, query_params, request_body, created_at, updated_at
`

type UpdateEndpointParams struct {
	Name        string `db:"name" json:"name"`
	Method      string `db:"method" json:"method"`
	Url         string `db:"url" json:"url"`
	Headers     string `db:"headers" json:"headers"`
	QueryParams string `db:"query_params" json:"query_params"`
	RequestBody string `db:"request_body" json:"request_body"`
	ID          int64  `db:"id" json:"id"`
}

func (q *Queries) UpdateEndpoint(ctx context.Context, arg UpdateEndpointParams) (Endpoint, error) {
	row := q.db.QueryRowContext(ctx, updateEndpoint,
		arg.Name,
		arg.Method,
		arg.Url,
		arg.Headers,
		arg.QueryParams,
		arg.RequestBody,
		arg.ID,
	)
	var i Endpoint
	err := row.Scan(
		&i.ID,
		&i.CollectionID,
		&i.Name,
		&i.Method,
		&i.Url,
		&i.Headers,
		&i.QueryParams,
		&i.RequestBody,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const updateEndpointName = `-- name: UpdateEndpointName :one
UPDATE endpoints
SET
    name = ?
WHERE
    id = ?
RETURNING id, collection_id, name, method, url, headers, query_params, request_body, created_at, updated_at
`

type UpdateEndpointNameParams struct {
	Name string `db:"name" json:"name"`
	ID   int64  `db:"id" json:"id"`
}

func (q *Queries) UpdateEndpointName(ctx context.Context, arg UpdateEndpointNameParams) (Endpoint, error) {
	row := q.db.QueryRowContext(ctx, updateEndpointName, arg.Name, arg.ID)
	var i Endpoint
	err := row.Scan(
		&i.ID,
		&i.CollectionID,
		&i.Name,
		&i.Method,
		&i.Url,
		&i.Headers,
		&i.QueryParams,
		&i.RequestBody,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}