member-console/internal/billing/subscription_items.sql.go

// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Commercial
// SPDX-FileCopyrightText: 2025-2026 Christian Galo

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

package billing

import (
	"context"

	"github.com/lib/pq"
)

const createSubscriptionItem = `-- name: CreateSubscriptionItem :one
INSERT INTO core.subscription_items (subscription_id, product_id, price_id, quantity)
VALUES ($1, $2, $3, $4)
RETURNING subscription_item_id, subscription_id, product_id, price_id, quantity, created_at, updated_at, ended_at
`

type CreateSubscriptionItemParams struct {
	SubscriptionID string `json:"subscription_id"`
	ProductID      string `json:"product_id"`
	PriceID        string `json:"price_id"`
	Quantity       int32  `json:"quantity"`
}

func (q *Queries) CreateSubscriptionItem(ctx context.Context, arg CreateSubscriptionItemParams) (SubscriptionItem, error) {
	row := q.db.QueryRowContext(ctx, createSubscriptionItem,
		arg.SubscriptionID,
		arg.ProductID,
		arg.PriceID,
		arg.Quantity,
	)
	var i SubscriptionItem
	err := row.Scan(
		&i.SubscriptionItemID,
		&i.SubscriptionID,
		&i.ProductID,
		&i.PriceID,
		&i.Quantity,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.EndedAt,
	)
	return i, err
}

const endSubscriptionItem = `-- name: EndSubscriptionItem :execrows
UPDATE core.subscription_items
SET ended_at = NOW()
WHERE subscription_item_id = $1 AND ended_at IS NULL
`

// Mark an item as no longer on its subscription (reconcile, when its Stripe
// item is gone from the subscription). A row already ended is left as it is.
func (q *Queries) EndSubscriptionItem(ctx context.Context, subscriptionItemID string) (int64, error) {
	result, err := q.db.ExecContext(ctx, endSubscriptionItem, subscriptionItemID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const getSubscriptionItemByID = `-- name: GetSubscriptionItemByID :one
SELECT subscription_item_id, subscription_id, product_id, price_id, quantity, created_at, updated_at, ended_at FROM core.subscription_items
WHERE subscription_item_id = $1
`

func (q *Queries) GetSubscriptionItemByID(ctx context.Context, subscriptionItemID string) (SubscriptionItem, error) {
	row := q.db.QueryRowContext(ctx, getSubscriptionItemByID, subscriptionItemID)
	var i SubscriptionItem
	err := row.Scan(
		&i.SubscriptionItemID,
		&i.SubscriptionID,
		&i.ProductID,
		&i.PriceID,
		&i.Quantity,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.EndedAt,
	)
	return i, err
}

const getSubscriptionItemsBySubscriptionID = `-- name: GetSubscriptionItemsBySubscriptionID :many
SELECT subscription_item_id, subscription_id, product_id, price_id, quantity, created_at, updated_at, ended_at FROM core.subscription_items
WHERE subscription_id = $1 AND ended_at IS NULL
ORDER BY created_at ASC
`

// The subscription's current items: an item Stripe replaced (a schedule's
// phase change does) keeps its row for the invoice lines that reference it,
// with ended_at set, and is not returned.
func (q *Queries) GetSubscriptionItemsBySubscriptionID(ctx context.Context, subscriptionID string) ([]SubscriptionItem, error) {
	rows, err := q.db.QueryContext(ctx, getSubscriptionItemsBySubscriptionID, subscriptionID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []SubscriptionItem{}
	for rows.Next() {
		var i SubscriptionItem
		if err := rows.Scan(
			&i.SubscriptionItemID,
			&i.SubscriptionID,
			&i.ProductID,
			&i.PriceID,
			&i.Quantity,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.EndedAt,
		); 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 listCurrentSubscriptionItemsByBillingAccountID = `-- name: ListCurrentSubscriptionItemsByBillingAccountID :many
SELECT si.subscription_id, si.product_id
FROM core.subscription_items si
JOIN core.subscriptions s USING (subscription_id)
WHERE s.billing_account_id = $1::uuid
  AND si.ended_at IS NULL
ORDER BY si.subscription_id, si.product_id
`

type ListCurrentSubscriptionItemsByBillingAccountIDRow struct {
	SubscriptionID string `json:"subscription_id"`
	ProductID      string `json:"product_id"`
}

// The current items of every subscription of the billing account, the rows
// mirrorItems writes, in one statement for the organization page's Billing
// card (displaced-subscription-waits D4).
func (q *Queries) ListCurrentSubscriptionItemsByBillingAccountID(ctx context.Context, billingAccountID string) ([]ListCurrentSubscriptionItemsByBillingAccountIDRow, error) {
	rows, err := q.db.QueryContext(ctx, listCurrentSubscriptionItemsByBillingAccountID, billingAccountID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListCurrentSubscriptionItemsByBillingAccountIDRow{}
	for rows.Next() {
		var i ListCurrentSubscriptionItemsByBillingAccountIDRow
		if err := rows.Scan(&i.SubscriptionID, &i.ProductID); 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 listCurrentSubscriptionItemsBySubscriptionIDs = `-- name: ListCurrentSubscriptionItemsBySubscriptionIDs :many
SELECT si.subscription_id, si.product_id
FROM core.subscription_items si
WHERE si.subscription_id = ANY($1::uuid[])
  AND si.ended_at IS NULL
ORDER BY si.subscription_id, si.product_id
`

type ListCurrentSubscriptionItemsBySubscriptionIDsRow struct {
	SubscriptionID string `json:"subscription_id"`
	ProductID      string `json:"product_id"`
}

// The current items of one page of the operator's subscriptions list, the
// rows mirrorItems writes, in one statement for the page
// (displaced-subscription-waits D4).
func (q *Queries) ListCurrentSubscriptionItemsBySubscriptionIDs(ctx context.Context, subscriptionIds []string) ([]ListCurrentSubscriptionItemsBySubscriptionIDsRow, error) {
	rows, err := q.db.QueryContext(ctx, listCurrentSubscriptionItemsBySubscriptionIDs, pq.Array(subscriptionIds))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListCurrentSubscriptionItemsBySubscriptionIDsRow{}
	for rows.Next() {
		var i ListCurrentSubscriptionItemsBySubscriptionIDsRow
		if err := rows.Scan(&i.SubscriptionID, &i.ProductID); 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 updateSubscriptionItemPriceProduct = `-- name: UpdateSubscriptionItemPriceProduct :one
UPDATE core.subscription_items
SET product_id = $2, price_id = $3, quantity = $4
WHERE subscription_item_id = $1
RETURNING subscription_item_id, subscription_id, product_id, price_id, quantity, created_at, updated_at, ended_at
`

type UpdateSubscriptionItemPriceProductParams struct {
	SubscriptionItemID string `json:"subscription_item_id"`
	ProductID          string `json:"product_id"`
	PriceID            string `json:"price_id"`
	Quantity           int32  `json:"quantity"`
}

// Converge a core item row after an in-place Stripe price modification (paid->paid
// switch): the Stripe item id is unchanged but it now carries a new price/product.
func (q *Queries) UpdateSubscriptionItemPriceProduct(ctx context.Context, arg UpdateSubscriptionItemPriceProductParams) (SubscriptionItem, error) {
	row := q.db.QueryRowContext(ctx, updateSubscriptionItemPriceProduct,
		arg.SubscriptionItemID,
		arg.ProductID,
		arg.PriceID,
		arg.Quantity,
	)
	var i SubscriptionItem
	err := row.Scan(
		&i.SubscriptionItemID,
		&i.SubscriptionID,
		&i.ProductID,
		&i.PriceID,
		&i.Quantity,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.EndedAt,
	)
	return i, err
}