mirror of
https://github.com/memohai/Memoh.git
synced 2026-04-25 07:00:48 +09:00
Acbox
6328281fc2
SQL queries (CountProviders, CountModels, ListModels, ListEnabledModels, ListModelsByProviderID) now exclude speech types. Added IsLLMClientType guard to prevent cross-domain queries via /models?client_type and /providers/:id/import-models. Frontend provider forms no longer offer edge-speech as a client type option. Also fixed pre-existing SA5011 staticcheck warnings in proxy_test.go and executor_test.go.
1055 lines
24 KiB
Go
1055 lines
24 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.30.0
|
|
// source: models.sql
|
|
|
|
package sqlc
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const countModels = `-- name: CountModels :one
|
|
SELECT COUNT(*) FROM models
|
|
WHERE type != 'speech'
|
|
`
|
|
|
|
func (q *Queries) CountModels(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countModels)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countModelsByType = `-- name: CountModelsByType :one
|
|
SELECT COUNT(*) FROM models WHERE type = $1
|
|
`
|
|
|
|
func (q *Queries) CountModelsByType(ctx context.Context, type_ string) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countModelsByType, type_)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countProviders = `-- name: CountProviders :one
|
|
SELECT COUNT(*) FROM providers
|
|
WHERE client_type NOT IN ('edge-speech')
|
|
`
|
|
|
|
func (q *Queries) CountProviders(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countProviders)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createModel = `-- name: CreateModel :one
|
|
INSERT INTO models (model_id, name, provider_id, type, config)
|
|
VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5
|
|
)
|
|
RETURNING id, model_id, name, provider_id, type, config, created_at, updated_at
|
|
`
|
|
|
|
type CreateModelParams struct {
|
|
ModelID string `json:"model_id"`
|
|
Name pgtype.Text `json:"name"`
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
Type string `json:"type"`
|
|
Config []byte `json:"config"`
|
|
}
|
|
|
|
func (q *Queries) CreateModel(ctx context.Context, arg CreateModelParams) (Model, error) {
|
|
row := q.db.QueryRow(ctx, createModel,
|
|
arg.ModelID,
|
|
arg.Name,
|
|
arg.ProviderID,
|
|
arg.Type,
|
|
arg.Config,
|
|
)
|
|
var i Model
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createModelVariant = `-- name: CreateModelVariant :one
|
|
INSERT INTO model_variants (model_uuid, variant_id, weight, metadata)
|
|
VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4
|
|
)
|
|
RETURNING id, model_uuid, variant_id, weight, metadata, created_at, updated_at
|
|
`
|
|
|
|
type CreateModelVariantParams struct {
|
|
ModelUuid pgtype.UUID `json:"model_uuid"`
|
|
VariantID string `json:"variant_id"`
|
|
Weight int32 `json:"weight"`
|
|
Metadata []byte `json:"metadata"`
|
|
}
|
|
|
|
func (q *Queries) CreateModelVariant(ctx context.Context, arg CreateModelVariantParams) (ModelVariant, error) {
|
|
row := q.db.QueryRow(ctx, createModelVariant,
|
|
arg.ModelUuid,
|
|
arg.VariantID,
|
|
arg.Weight,
|
|
arg.Metadata,
|
|
)
|
|
var i ModelVariant
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelUuid,
|
|
&i.VariantID,
|
|
&i.Weight,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createProvider = `-- name: CreateProvider :one
|
|
INSERT INTO providers (name, client_type, icon, enable, config, metadata)
|
|
VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6
|
|
)
|
|
RETURNING id, name, client_type, icon, enable, config, metadata, created_at, updated_at
|
|
`
|
|
|
|
type CreateProviderParams struct {
|
|
Name string `json:"name"`
|
|
ClientType string `json:"client_type"`
|
|
Icon pgtype.Text `json:"icon"`
|
|
Enable bool `json:"enable"`
|
|
Config []byte `json:"config"`
|
|
Metadata []byte `json:"metadata"`
|
|
}
|
|
|
|
func (q *Queries) CreateProvider(ctx context.Context, arg CreateProviderParams) (Provider, error) {
|
|
row := q.db.QueryRow(ctx, createProvider,
|
|
arg.Name,
|
|
arg.ClientType,
|
|
arg.Icon,
|
|
arg.Enable,
|
|
arg.Config,
|
|
arg.Metadata,
|
|
)
|
|
var i Provider
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const deleteModel = `-- name: DeleteModel :exec
|
|
DELETE FROM models WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteModel(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteModel, id)
|
|
return err
|
|
}
|
|
|
|
const deleteModelByModelID = `-- name: DeleteModelByModelID :exec
|
|
DELETE FROM models WHERE model_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteModelByModelID(ctx context.Context, modelID string) error {
|
|
_, err := q.db.Exec(ctx, deleteModelByModelID, modelID)
|
|
return err
|
|
}
|
|
|
|
const deleteProvider = `-- name: DeleteProvider :exec
|
|
DELETE FROM providers WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteProvider(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteProvider, id)
|
|
return err
|
|
}
|
|
|
|
const getModelByID = `-- name: GetModelByID :one
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetModelByID(ctx context.Context, id pgtype.UUID) (Model, error) {
|
|
row := q.db.QueryRow(ctx, getModelByID, id)
|
|
var i Model
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getModelByModelID = `-- name: GetModelByModelID :one
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models WHERE model_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetModelByModelID(ctx context.Context, modelID string) (Model, error) {
|
|
row := q.db.QueryRow(ctx, getModelByModelID, modelID)
|
|
var i Model
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getModelByProviderAndModelID = `-- name: GetModelByProviderAndModelID :one
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE provider_id = $1
|
|
AND model_id = $2
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetModelByProviderAndModelIDParams struct {
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
ModelID string `json:"model_id"`
|
|
}
|
|
|
|
func (q *Queries) GetModelByProviderAndModelID(ctx context.Context, arg GetModelByProviderAndModelIDParams) (Model, error) {
|
|
row := q.db.QueryRow(ctx, getModelByProviderAndModelID, arg.ProviderID, arg.ModelID)
|
|
var i Model
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getProviderByID = `-- name: GetProviderByID :one
|
|
SELECT id, name, client_type, icon, enable, config, metadata, created_at, updated_at FROM providers WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetProviderByID(ctx context.Context, id pgtype.UUID) (Provider, error) {
|
|
row := q.db.QueryRow(ctx, getProviderByID, id)
|
|
var i Provider
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getProviderByName = `-- name: GetProviderByName :one
|
|
SELECT id, name, client_type, icon, enable, config, metadata, created_at, updated_at FROM providers WHERE name = $1
|
|
`
|
|
|
|
func (q *Queries) GetProviderByName(ctx context.Context, name string) (Provider, error) {
|
|
row := q.db.QueryRow(ctx, getProviderByName, name)
|
|
var i Provider
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSpeechModelWithProvider = `-- name: GetSpeechModelWithProvider :one
|
|
SELECT
|
|
m.id, m.model_id, m.name, m.provider_id, m.type, m.config, m.created_at, m.updated_at,
|
|
p.client_type AS provider_type
|
|
FROM models m
|
|
JOIN providers p ON p.id = m.provider_id
|
|
WHERE m.id = $1
|
|
AND m.type = 'speech'
|
|
`
|
|
|
|
type GetSpeechModelWithProviderRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
ModelID string `json:"model_id"`
|
|
Name pgtype.Text `json:"name"`
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
Type string `json:"type"`
|
|
Config []byte `json:"config"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ProviderType string `json:"provider_type"`
|
|
}
|
|
|
|
func (q *Queries) GetSpeechModelWithProvider(ctx context.Context, id pgtype.UUID) (GetSpeechModelWithProviderRow, error) {
|
|
row := q.db.QueryRow(ctx, getSpeechModelWithProvider, id)
|
|
var i GetSpeechModelWithProviderRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ProviderType,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const listEnabledModels = `-- name: ListEnabledModels :many
|
|
SELECT m.id, m.model_id, m.name, m.provider_id, m.type, m.config, m.created_at, m.updated_at
|
|
FROM models m
|
|
JOIN providers p ON m.provider_id = p.id
|
|
WHERE p.enable = true
|
|
AND m.type != 'speech'
|
|
ORDER BY m.created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListEnabledModels(ctx context.Context) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listEnabledModels)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listEnabledModelsByProviderClientType = `-- name: ListEnabledModelsByProviderClientType :many
|
|
SELECT m.id, m.model_id, m.name, m.provider_id, m.type, m.config, m.created_at, m.updated_at
|
|
FROM models m
|
|
JOIN providers p ON m.provider_id = p.id
|
|
WHERE p.enable = true
|
|
AND p.client_type = $1
|
|
ORDER BY m.created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListEnabledModelsByProviderClientType(ctx context.Context, clientType string) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listEnabledModelsByProviderClientType, clientType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listEnabledModelsByType = `-- name: ListEnabledModelsByType :many
|
|
SELECT m.id, m.model_id, m.name, m.provider_id, m.type, m.config, m.created_at, m.updated_at
|
|
FROM models m
|
|
JOIN providers p ON m.provider_id = p.id
|
|
WHERE p.enable = true
|
|
AND m.type = $1
|
|
ORDER BY m.created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListEnabledModelsByType(ctx context.Context, type_ string) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listEnabledModelsByType, type_)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModelVariantsByModelUUID = `-- name: ListModelVariantsByModelUUID :many
|
|
SELECT id, model_uuid, variant_id, weight, metadata, created_at, updated_at FROM model_variants
|
|
WHERE model_uuid = $1
|
|
ORDER BY weight DESC, created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListModelVariantsByModelUUID(ctx context.Context, modelUuid pgtype.UUID) ([]ModelVariant, error) {
|
|
rows, err := q.db.Query(ctx, listModelVariantsByModelUUID, modelUuid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ModelVariant
|
|
for rows.Next() {
|
|
var i ModelVariant
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelUuid,
|
|
&i.VariantID,
|
|
&i.Weight,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModels = `-- name: ListModels :many
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE type != 'speech'
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListModels(ctx context.Context) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listModels)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModelsByModelID = `-- name: ListModelsByModelID :many
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE model_id = $1
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListModelsByModelID(ctx context.Context, modelID string) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listModelsByModelID, modelID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModelsByProviderClientType = `-- name: ListModelsByProviderClientType :many
|
|
SELECT m.id, m.model_id, m.name, m.provider_id, m.type, m.config, m.created_at, m.updated_at
|
|
FROM models m
|
|
JOIN providers p ON m.provider_id = p.id
|
|
WHERE p.client_type = $1
|
|
ORDER BY m.created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListModelsByProviderClientType(ctx context.Context, clientType string) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listModelsByProviderClientType, clientType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModelsByProviderID = `-- name: ListModelsByProviderID :many
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE provider_id = $1
|
|
AND type != 'speech'
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListModelsByProviderID(ctx context.Context, providerID pgtype.UUID) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listModelsByProviderID, providerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModelsByProviderIDAndType = `-- name: ListModelsByProviderIDAndType :many
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE provider_id = $1
|
|
AND type = $2
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
type ListModelsByProviderIDAndTypeParams struct {
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
Type string `json:"type"`
|
|
}
|
|
|
|
func (q *Queries) ListModelsByProviderIDAndType(ctx context.Context, arg ListModelsByProviderIDAndTypeParams) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listModelsByProviderIDAndType, arg.ProviderID, arg.Type)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listModelsByType = `-- name: ListModelsByType :many
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE type = $1
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListModelsByType(ctx context.Context, type_ string) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listModelsByType, type_)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listProviders = `-- name: ListProviders :many
|
|
SELECT id, name, client_type, icon, enable, config, metadata, created_at, updated_at FROM providers
|
|
WHERE client_type NOT IN ('edge-speech')
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListProviders(ctx context.Context) ([]Provider, error) {
|
|
rows, err := q.db.Query(ctx, listProviders)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Provider
|
|
for rows.Next() {
|
|
var i Provider
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listSpeechModels = `-- name: ListSpeechModels :many
|
|
SELECT m.id, m.model_id, m.name, m.provider_id, m.type, m.config, m.created_at, m.updated_at,
|
|
p.client_type AS provider_type
|
|
FROM models m
|
|
JOIN providers p ON p.id = m.provider_id
|
|
WHERE m.type = 'speech'
|
|
ORDER BY m.created_at DESC
|
|
`
|
|
|
|
type ListSpeechModelsRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
ModelID string `json:"model_id"`
|
|
Name pgtype.Text `json:"name"`
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
Type string `json:"type"`
|
|
Config []byte `json:"config"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ProviderType string `json:"provider_type"`
|
|
}
|
|
|
|
func (q *Queries) ListSpeechModels(ctx context.Context) ([]ListSpeechModelsRow, error) {
|
|
rows, err := q.db.Query(ctx, listSpeechModels)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListSpeechModelsRow
|
|
for rows.Next() {
|
|
var i ListSpeechModelsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ProviderType,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listSpeechModelsByProviderID = `-- name: ListSpeechModelsByProviderID :many
|
|
SELECT id, model_id, name, provider_id, type, config, created_at, updated_at FROM models
|
|
WHERE provider_id = $1
|
|
AND type = 'speech'
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListSpeechModelsByProviderID(ctx context.Context, providerID pgtype.UUID) ([]Model, error) {
|
|
rows, err := q.db.Query(ctx, listSpeechModelsByProviderID, providerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Model
|
|
for rows.Next() {
|
|
var i Model
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listSpeechProviders = `-- name: ListSpeechProviders :many
|
|
SELECT id, name, client_type, icon, enable, config, metadata, created_at, updated_at FROM providers
|
|
WHERE client_type IN ('edge-speech')
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListSpeechProviders(ctx context.Context) ([]Provider, error) {
|
|
rows, err := q.db.Query(ctx, listSpeechProviders)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Provider
|
|
for rows.Next() {
|
|
var i Provider
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const updateModel = `-- name: UpdateModel :one
|
|
UPDATE models
|
|
SET
|
|
model_id = $1,
|
|
name = $2,
|
|
provider_id = $3,
|
|
type = $4,
|
|
config = $5,
|
|
updated_at = now()
|
|
WHERE id = $6
|
|
RETURNING id, model_id, name, provider_id, type, config, created_at, updated_at
|
|
`
|
|
|
|
type UpdateModelParams struct {
|
|
ModelID string `json:"model_id"`
|
|
Name pgtype.Text `json:"name"`
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
Type string `json:"type"`
|
|
Config []byte `json:"config"`
|
|
ID pgtype.UUID `json:"id"`
|
|
}
|
|
|
|
func (q *Queries) UpdateModel(ctx context.Context, arg UpdateModelParams) (Model, error) {
|
|
row := q.db.QueryRow(ctx, updateModel,
|
|
arg.ModelID,
|
|
arg.Name,
|
|
arg.ProviderID,
|
|
arg.Type,
|
|
arg.Config,
|
|
arg.ID,
|
|
)
|
|
var i Model
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateProvider = `-- name: UpdateProvider :one
|
|
UPDATE providers
|
|
SET
|
|
name = $1,
|
|
client_type = $2,
|
|
icon = $3,
|
|
enable = $4,
|
|
config = $5,
|
|
metadata = $6,
|
|
updated_at = now()
|
|
WHERE id = $7
|
|
RETURNING id, name, client_type, icon, enable, config, metadata, created_at, updated_at
|
|
`
|
|
|
|
type UpdateProviderParams struct {
|
|
Name string `json:"name"`
|
|
ClientType string `json:"client_type"`
|
|
Icon pgtype.Text `json:"icon"`
|
|
Enable bool `json:"enable"`
|
|
Config []byte `json:"config"`
|
|
Metadata []byte `json:"metadata"`
|
|
ID pgtype.UUID `json:"id"`
|
|
}
|
|
|
|
func (q *Queries) UpdateProvider(ctx context.Context, arg UpdateProviderParams) (Provider, error) {
|
|
row := q.db.QueryRow(ctx, updateProvider,
|
|
arg.Name,
|
|
arg.ClientType,
|
|
arg.Icon,
|
|
arg.Enable,
|
|
arg.Config,
|
|
arg.Metadata,
|
|
arg.ID,
|
|
)
|
|
var i Provider
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const upsertRegistryModel = `-- name: UpsertRegistryModel :one
|
|
INSERT INTO models (model_id, name, provider_id, type, config)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
ON CONFLICT (provider_id, model_id) DO UPDATE SET
|
|
name = EXCLUDED.name,
|
|
type = EXCLUDED.type,
|
|
config = EXCLUDED.config,
|
|
updated_at = now()
|
|
RETURNING id, model_id, name, provider_id, type, config, created_at, updated_at
|
|
`
|
|
|
|
type UpsertRegistryModelParams struct {
|
|
ModelID string `json:"model_id"`
|
|
Name pgtype.Text `json:"name"`
|
|
ProviderID pgtype.UUID `json:"provider_id"`
|
|
Type string `json:"type"`
|
|
Config []byte `json:"config"`
|
|
}
|
|
|
|
func (q *Queries) UpsertRegistryModel(ctx context.Context, arg UpsertRegistryModelParams) (Model, error) {
|
|
row := q.db.QueryRow(ctx, upsertRegistryModel,
|
|
arg.ModelID,
|
|
arg.Name,
|
|
arg.ProviderID,
|
|
arg.Type,
|
|
arg.Config,
|
|
)
|
|
var i Model
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ModelID,
|
|
&i.Name,
|
|
&i.ProviderID,
|
|
&i.Type,
|
|
&i.Config,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const upsertRegistryProvider = `-- name: UpsertRegistryProvider :one
|
|
INSERT INTO providers (name, client_type, icon, enable, config, metadata)
|
|
VALUES ($1, $2, $3, false, $4, '{}')
|
|
ON CONFLICT (name) DO UPDATE SET
|
|
icon = EXCLUDED.icon,
|
|
client_type = EXCLUDED.client_type,
|
|
config = CASE
|
|
WHEN providers.config->>'api_key' IS NOT NULL AND providers.config->>'api_key' != ''
|
|
THEN jsonb_set(EXCLUDED.config, '{api_key}', providers.config->'api_key')
|
|
ELSE EXCLUDED.config
|
|
END,
|
|
updated_at = now()
|
|
RETURNING id, name, client_type, icon, enable, config, metadata, created_at, updated_at
|
|
`
|
|
|
|
type UpsertRegistryProviderParams struct {
|
|
Name string `json:"name"`
|
|
ClientType string `json:"client_type"`
|
|
Icon pgtype.Text `json:"icon"`
|
|
Config []byte `json:"config"`
|
|
}
|
|
|
|
func (q *Queries) UpsertRegistryProvider(ctx context.Context, arg UpsertRegistryProviderParams) (Provider, error) {
|
|
row := q.db.QueryRow(ctx, upsertRegistryProvider,
|
|
arg.Name,
|
|
arg.ClientType,
|
|
arg.Icon,
|
|
arg.Config,
|
|
)
|
|
var i Provider
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.ClientType,
|
|
&i.Icon,
|
|
&i.Enable,
|
|
&i.Config,
|
|
&i.Metadata,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|