datasourcessvc

type ConnectionTestExecutor interface {
	TestConnection(context.Context, ConnectionTestRequest) error
}

type ConnectionTestRequest struct {
	OrganizationSlug slug.Slug            `json:"organization_slug"`
	DataSourceSlug   slug.Slug            `json:"data_source_slug"`
	DataSourceType   model.DataSourceType `json:"data_source_type"`
	ConfigJSON       []byte               `json:"config_json"`
	CredentialsJSON  []byte               `json:"credentials_json"`
}

type CreateParams struct {
	Name        string               `validate:"required,min=1,max=100"`
	Slug        slug.Slug            // Empty slug will be generated from name
	Type        model.DataSourceType `validate:"required,datasourcetype"`
	ConfigJSON  json.RawMessage      `validate:"required"`
	Credentials map[string]any
	ReadOnly    bool
}

type CustomerConfigPolicy struct {
	AllowPlaintextConnectors    bool
	AllowPrivateDataSourceHosts bool
}

type DataSource struct {
	ConnectionRevision           int64
	OrganizationGitLabConnection bool
	Slug                         slug.Slug
	Name                         string
	Type                         model.DataSourceType
	Config                       json.RawMessage
	Schema                       SchemaResult
	SchemaCached                 bool
	SchemaImportStatus           model.DataSourceSchemaImportStatus
	SchemaImportDiagnostic       *SchemaImportDiagnostic
	SchemaImportStartedAt        *time.Time
	SchemaImportFinishedAt       *time.Time
	EncryptedCredentials         []byte
	Credential                   *credentialssvc.CredentialMetadata
	IsActive                     bool
	ReadOnly                     bool
	LastTestedAt                 *time.Time
	TestError                    *string
	CreatedAt                    time.Time
	UpdatedAt                    time.Time
}

type DataSourceBranch struct {
	Name      string
	IsDefault bool
}

type DocumentSchemaPayload struct {
	Collections []SchemaCollection `json:"collections"`
}

type FileSchemaPayload struct {
	Files       []SchemaFile           `json:"files"`
	Diagnostics []SchemaFileDiagnostic `json:"diagnostics,omitempty"`
}

type GitBranchExecutor interface {
	ListGitBranches(context.Context, GitBranchRequest) ([]DataSourceBranch, error)
}

type GitBranchRequest struct {
	OrganizationSlug slug.Slug        `json:"organization_slug"`
	Auth             GitExecutionAuth `json:"auth"`
	MaxResultBytes   int              `json:"max_result_bytes"`
	MaxResultItems   int              `json:"max_result_items"`
}

type GitDataSourceAuth struct {
	GitConfigurationHash  string
	GitWritable           bool
	GitDataSourceSlug     string
	GitCredentialSlug     string
	GitCredentialRevision string
	// Provider selects native PR/MR publication or plain Git proposal branches.
	Provider string
	// Env holds auth variables created from decrypted datasource credentials.
	// Provider HTTPS PATs are exposed here as GITHUB_TOKEN or GITLAB_TOKEN so
	// git operations and provider API calls can share the same resolved secret
	// without embedding it in RepoURL.
	Env []string
	// RepoURL is a sanitized repository URL whose native Git transport is pinned
	// through Env to the destination vetted by the data-source host policy.
	RepoURL string
	// DefaultBranch is the branch configured on the data source, may be empty.
	DefaultBranch string
	// GitHubContentsPermission is set only from a freshly minted GitHub App installation token.
	GitHubContentsPermission *string
	GitHubProposalAuthority  *GitHubProposalAuthority
	// Cleanup removes any temporary files created for this auth session (e.g. SSH key).
	Cleanup func()
}

type GitExecutionAuth struct {
	GitConfigurationHash     string                   `json:"git_configuration_hash,omitempty"`
	GitWritable              bool                     `json:"git_writable"`
	GitDataSourceSlug        string                   `json:"git_data_source_slug,omitempty"`
	GitCredentialSlug        string                   `json:"git_credential_slug,omitempty"`
	GitCredentialRevision    string                   `json:"git_credential_revision,omitempty"`
	CredentialReference      string                   `json:"credential_reference"`
	DataSourceType           model.DataSourceType     `json:"data_source_type"`
	ConfigJSON               []byte                   `json:"config_json"`
	CredentialsJSON          []byte                   `json:"credentials_json"`
	GitHubContentsPermission *string                  `json:"github_contents_permission,omitempty"`
	GitHubProposalAuthority  *GitHubProposalAuthority `json:"github_proposal_authority,omitempty"`
}

type GitHubAppManager interface {
	Get(context.Context, slug.Slug) (*githubappsvc.Connection, error)
	Token(context.Context, slug.Slug, []int64) (githubappsvc.InstallationToken, error)
}

type GitHubProposalAuthority struct {
	CredentialSlug slug.Slug                       `json:"credential_slug"`
	Authority      model.PipelineProposalAuthority `json:"authority"`
}

type GitLabWebhookManager interface {
	Ensure(context.Context, slug.Slug, slug.Slug, []byte, []byte) error
}

type HTTPOAuthConnection struct {
	DataSource *DataSource
	Install    *credentialssvc.ProviderConnectorInstall
}

type HTTPSchemaPayload struct {
	Operations []SchemaOperation `json:"operations"`
}

type ObjectAPISchemaPayload struct {
	Objects []SchemaObjectAPIObject `json:"objects"`
}

type ProviderDataSourceInstall struct {
	DataSource *DataSource
	Install    credentialssvc.ProviderConnectorInstall
}

type ProviderRepository struct {
	ID            string
	Name          string
	FullName      string
	WebURL        string
	DefaultBranch string
}

type QueuedSchemaImportJob struct {
	Kind  string
	Queue string
	State string
}

type SQLSchemaPayload struct {
	Tables []SchemaTable `json:"tables"`
}

type Schema[T any] struct {
	SchemaTypeValue SchemaType `json:"schema_type"`
	Type            string     `json:"type"`
	Payload         T          `json:"payload"`
}

type SchemaCollection struct {
	Name   string        `json:"name"`
	Fields []SchemaField `json:"fields"`
}

type SchemaColumn struct {
	Name     string `json:"name"`
	Type     string `json:"type"`
	Nullable bool   `json:"nullable,omitempty"`
}

type SchemaField struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type SchemaFile struct {
	ResourceID string        `json:"resource_id,omitempty"`
	SizeBytes  *int64        `json:"size_bytes,omitempty"`
	MIMEType   string        `json:"mime_type,omitempty"`
	Name       string        `json:"name"`
	Fields     []SchemaField `json:"fields"`
}

type SchemaFileDiagnostic struct {
	Name     string `json:"name"`
	Target   string `json:"target"`
	Severity string `json:"severity"`
	Code     string `json:"code"`
	Message  string `json:"message"`
}

type SchemaImportDiagnostic struct {
	Code    string
	Message string
}

type SchemaImportResult struct {
	DataSourceSlug slug.Slug
	Status         model.DataSourceSchemaImportStatus
	Diagnostic     *SchemaImportDiagnostic
	Skipped        bool
	StartedAt      *time.Time
	FinishedAt     *time.Time
	Enqueued       bool
	Job            *QueuedSchemaImportJob
}

type SchemaIntrospectionExecutor interface {
	IntrospectSchema(context.Context, SchemaIntrospectionRequest) ([]byte, error)
}

type SchemaIntrospectionRequest struct {
	OrganizationSlug slug.Slug            `json:"organization_slug"`
	DataSourceSlug   slug.Slug            `json:"data_source_slug"`
	DataSourceType   model.DataSourceType `json:"data_source_type"`
	ConfigJSON       []byte               `json:"config_json"`
	CredentialsJSON  []byte               `json:"credentials_json"`
	MaxResultBytes   int                  `json:"max_result_bytes"`
	MaxResultItems   int                  `json:"max_result_items"`
}

type SchemaObjectAPIField struct {
	Name             string         `json:"name"`
	Label            string         `json:"label,omitempty"`
	Type             string         `json:"type"`
	ProviderMetadata map[string]any `json:"provider_metadata,omitempty"`
}

type SchemaObjectAPIObject struct {
	Name             string                     `json:"name"`
	Label            string                     `json:"label,omitempty"`
	Fields           []SchemaObjectAPIField     `json:"fields"`
	Operations       []SchemaObjectAPIOperation `json:"operations,omitempty"`
	ProviderMetadata map[string]any             `json:"provider_metadata,omitempty"`
}

type SchemaObjectAPIOperation struct {
	Name             string         `json:"name"`
	Label            string         `json:"label,omitempty"`
	ProviderMetadata map[string]any `json:"provider_metadata,omitempty"`
}

type SchemaOperation struct {
	Draft       json.RawMessage `json:"draft,omitempty"`
	Diagnostics []string        `json:"diagnostics,omitempty"`
	ID          string          `json:"id"`
	Path        string          `json:"path"`
	Method      string          `json:"method"`
	Description string          `json:"description,omitempty"`
	RequestBody json.RawMessage `json:"request_body,omitempty"`
	Responses   json.RawMessage `json:"responses,omitempty"`
}

type SchemaResult interface {
	SchemaType() SchemaType
	VendorType() string
}

type SchemaTable struct {
	Name    string         `json:"name"`
	Columns []SchemaColumn `json:"columns"`
}

type SchemaType int

type SelectProviderRepositoryParams struct {
	RepositoryID string `validate:"required"`
}

type Service interface {
	ConnectHTTPOAuth(context.Context, slug.Slug, slug.Slug, model.EventActor) (*HTTPOAuthConnection, error)
	AttachOrganizationGitLabConnection(context.Context, slug.Slug, slug.Slug, model.EventActor) error
	Create(
		ctx context.Context,
		orgSlug slug.Slug,
		actor model.EventActor,
		params *CreateParams,
	) (*DataSource, error)
	CreateProvisioned(ctx context.Context, orgSlug slug.Slug, actor model.EventActor, params *CreateParams, provisioner SourceProvisioner) (*DataSource, error)
	// StartProviderDataSourceInstall atomically creates a pending read-only provider data source and starts OAuth consent.
	StartProviderDataSourceInstall(
		ctx context.Context,
		orgSlug slug.Slug,
		actor model.EventActor,
		provider string,
		params *StartProviderDataSourceInstallParams,
	) (*ProviderDataSourceInstall, error)
	GetGoogleWorkspacePicker(context.Context, slug.Slug, slug.Slug) (*WorkspacePicker, error)
	ListGoogleWorkspaceFiles(ctx context.Context, orgSlug, dsSlug slug.Slug, options workspace.ListOptions) (*workspace.Discovery, error)
	GetGoogleWorkspaceFile(context.Context, slug.Slug, slug.Slug, string) (*workspace.File, error)
	GetGoogleWorkspaceWorksheets(context.Context, slug.Slug, slug.Slug, string) (*workspace.Metadata, error)
	VerifyGoogleWorkspaceFiles(context.Context, slug.Slug, slug.Slug, model.EventActor, WorkspaceVerificationParams) (*workspace.Discovery, error)
	ListProviderRepositories(ctx context.Context, orgSlug, dsSlug slug.Slug) ([]ProviderRepository, error)
	SelectProviderRepository(ctx context.Context, orgSlug, dsSlug slug.Slug, actor model.EventActor, params SelectProviderRepositoryParams) (*DataSource, error)
	TestConnection(ctx context.Context, orgSlug slug.Slug, params *TestConnectionParams) error
	TestExistingConnection(ctx context.Context, orgSlug, dsSlug slug.Slug) error
	GetSnowflakeOnboarding(ctx context.Context, orgSlug, dsSlug slug.Slug) (*SnowflakeOnboarding, error)
	FindBySlug(ctx context.Context, orgSlug, dsSlug slug.Slug) (*DataSource, error)
	ListByOrg(
		ctx context.Context,
		orgSlug slug.Slug,
		req model.ListRequest,
	) (model.ListResponse[DataSource], error)
	Update(
		ctx context.Context,
		orgSlug, dsSlug slug.Slug,
		actor model.EventActor,
		params *UpdateParams,
	) (*DataSource, error)
	UpdateCredentials(
		ctx context.Context,
		orgSlug, dsSlug slug.Slug,
		actor model.EventActor,
		params *UpdateCredentialsParams,
	) (*DataSource, error)
	CompleteProviderOAuthCallback(
		ctx context.Context,
		params credentialssvc.CompleteOAuthCallbackParams,
	) (credentialssvc.CompleteOAuthCallbackResult, error)
	ValidateCredentialLifecycle(
		ctx context.Context,
		orgSlug, dsSlug slug.Slug,
		actor model.EventActor,
		action model.EventAction,
	) (*DataSource, error)
	RecordCredentialLifecycleEvent(
		ctx context.Context,
		orgSlug, dsSlug slug.Slug,
		actor model.EventActor,
		action model.EventAction,
	) error
	ListBranches(ctx context.Context, orgSlug, dsSlug slug.Slug) ([]DataSourceBranch, error)
	IntrospectSchema(ctx context.Context, orgSlug, dsSlug slug.Slug) (SchemaResult, error)
	RefreshSchema(
		ctx context.Context,
		orgSlug, dsSlug slug.Slug,
		actor model.EventActor,
	) (*SchemaImportResult, error)
	ExecuteQueuedSchemaImport(ctx context.Context, args jobs.DataSourceSchemaImportArgs) (*SchemaImportResult, error)
	Delete(ctx context.Context, orgSlug, dsSlug slug.Slug, actor model.EventActor) error
	Restore(ctx context.Context, orgSlug, dsSlug slug.Slug, actor model.EventActor) error
	// ResolveGitAuth returns the authentication components needed to perform raw git
	// operations against a git-compatible data source's configured repository.
	// The returned GitDataSourceAuth.Cleanup must be called when operations complete.
	// Returns ErrDataSourceNotFound if the slug does not exist.
	// Returns ErrInvalidDataSourceType if the data source is not git, github, or gitlab.
	ResolveGitAuth(ctx context.Context, orgSlug, dsSlug slug.Slug) (*GitDataSourceAuth, error)
	EnsureProofWebhook(ctx context.Context, orgSlug, dsSlug slug.Slug) error
	ResolveGitExecutionAuth(ctx context.Context, orgSlug, dsSlug slug.Slug) (*GitExecutionAuth, error)
}

type ServiceConfig struct {
	HTTPOAuthRedirectURI        string
	GoogleWorkspacePicker       WorkspacePickerSettings
	SnowflakeWIFIssuer          string
	CustomerConfigPolicy        CustomerConfigPolicy
	ConnectionTestExecutor      ConnectionTestExecutor
	SchemaIntrospectionExecutor SchemaIntrospectionExecutor
	SchemaMaxBytes              int
	SchemaMaxItems              int
	GitBranchExecutor           GitBranchExecutor
	GitBranchMaxBytes           int
	GitBranchMaxItems           int
}

type ServiceWithLogging struct {
	// contains filtered or unexported fields
}

type SnowflakeOnboarding struct {
	IdentityState string
	Active        bool
	Issuer        string
	Subject       string
	Audience      string
	SQL           string
	Diagnostic    string
}

type SourceProvisioner interface {
	Provision(context.Context, postgres.DBTX, slug.Slug, *repods.CreateParams) error
}

type SpreadsheetSchemaPayload = workspace.Metadata

type StartProviderDataSourceInstallParams struct {
	Name       string `validate:"required,min=1,max=100"`
	Slug       slug.Slug
	Type       model.DataSourceType `validate:"required,datasourcetype"`
	ConfigJSON json.RawMessage      `validate:"required"`
	ReadOnly   *bool
}

type TestConnectionParams struct {
	Type        model.DataSourceType `validate:"required,datasourcetype"`
	ConfigJSON  json.RawMessage      `validate:"required"`
	Credentials map[string]any
}

type UpdateCredentialsParams struct {
	Credentials map[string]any `validate:"required"`
}

type UpdateParams struct {
	Name               string `validate:"omitempty,min=1,max=100"`
	ConfigJSON         json.RawMessage
	ConfigFromCustomer bool
	IsActive           *bool
	ReadOnly           bool
	ReadOnlySet        bool
}

type WorkspacePicker struct {
	WorkspacePickerSettings
	AccountEmail     string
	ExpectedRevision int64
}

type WorkspacePickerSettings struct {
	ClientID     string
	DeveloperKey string
	AppID        string
}

type WorkspaceVerificationParams struct {
	FileIDs          []string
	ExpectedRevision int64
}