prisma

package
v0.49.1-alpha.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 4, 2024 License: MIT Imports: 33 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewAPIRepository 

func NewAPIRepository(client *db.PrismaClient, pool *pgxpool.Pool, fs ...PrismaRepositoryOpt) repository.APIRepository

func NewAPITokenRepository 

func NewAPITokenRepository(client *db.PrismaClient, v validator.Validator, cache cache.Cacheable) repository.APITokenRepository

func NewDispatcherRepository 

func NewDispatcherRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.DispatcherEngineRepository

func NewEngineRepository 

func NewEngineRepository(pool *pgxpool.Pool, cf *server.ConfigFileRuntime, fs ...PrismaRepositoryOpt) (func() error, repository.EngineRepository, error)

func NewEngineTokenRepository 

func NewEngineTokenRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, cache cache.Cacheable) repository.EngineTokenRepository

func NewEntitlementRepository 

func NewEntitlementRepository(pool *pgxpool.Pool, s *server.ConfigFileRuntime, fs ...PrismaRepositoryOpt) repository.EntitlementsRepository

func NewEventAPIRepository 

func NewEventAPIRepository(client *db.PrismaClient, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.EventAPIRepository

func NewEventEngineRepository 

func NewEventEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, m *metered.Metered) (repository.EventEngineRepository, func() error, error)

func NewGetGroupKeyRunRepository 

func NewGetGroupKeyRunRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.GetGroupKeyRunEngineRepository

func NewHealthAPIRepository 

func NewHealthAPIRepository(client *db.PrismaClient, pool *pgxpool.Pool) repository.HealthRepository

func NewHealthEngineRepository 

func NewHealthEngineRepository(pool *pgxpool.Pool) repository.HealthRepository

func NewJobRunAPIRepository 

func NewJobRunAPIRepository(client *db.PrismaClient, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.JobRunAPIRepository

func NewJobRunEngineRepository 

func NewJobRunEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.JobRunEngineRepository

func NewLogAPIRepository 

func NewLogAPIRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.LogsAPIRepository

func NewLogEngineRepository 

func NewLogEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.LogsEngineRepository

func NewRateLimitEngineRepository 

func NewRateLimitEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.RateLimitEngineRepository

func NewSNSRepository 

func NewSNSRepository(client *db.PrismaClient, v validator.Validator) repository.SNSRepository

func NewSecurityCheckRepository added in v0.34.2 

func NewSecurityCheckRepository(client *db.PrismaClient, pool *pgxpool.Pool) repository.SecurityCheckRepository

func NewSlackRepository 

func NewSlackRepository(client *db.PrismaClient, v validator.Validator) repository.SlackRepository

func NewStepRepository 

func NewStepRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.StepRepository

func NewStepRunAPIRepository 

func NewStepRunAPIRepository(client *db.PrismaClient, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.StepRunAPIRepository

func NewStepRunEngineRepository 

func NewStepRunEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, cf *server.ConfigFileRuntime, rlCache *cache.Cache) (*stepRunEngineRepository, func() error, error)

func NewStreamEventsEngineRepository 

func NewStreamEventsEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.StreamEventsEngineRepository

func NewTenantAPIRepository 

func NewTenantAPIRepository(pool *pgxpool.Pool, client *db.PrismaClient, v validator.Validator, l *zerolog.Logger, cache cache.Cacheable) repository.TenantAPIRepository

func NewTenantAlertingAPIRepository 

func NewTenantAlertingAPIRepository(client *db.PrismaClient, v validator.Validator, cache cache.Cacheable) repository.TenantAlertingAPIRepository

func NewTenantAlertingEngineRepository 

func NewTenantAlertingEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, cache cache.Cacheable) repository.TenantAlertingEngineRepository

func NewTenantEngineRepository 

func NewTenantEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, cache cache.Cacheable) repository.TenantEngineRepository

func NewTenantInviteRepository 

func NewTenantInviteRepository(client *db.PrismaClient, v validator.Validator) repository.TenantInviteRepository

func NewTenantLimitRepository 

func NewTenantLimitRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, s *server.ConfigFileRuntime) repository.TenantLimitRepository

func NewTickerRepository 

func NewTickerRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.TickerEngineRepository

func NewUserRepository 

func NewUserRepository(client *db.PrismaClient, v validator.Validator) repository.UserRepository

func NewUserSessionRepository 

func NewUserSessionRepository(client *db.PrismaClient, v validator.Validator) repository.UserSessionRepository

func NewWebhookWorkerEngineRepository added in v0.34.0 

func NewWebhookWorkerEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.WebhookWorkerEngineRepository

func NewWebhookWorkerRepository added in v0.34.0 

func NewWebhookWorkerRepository(client *db.PrismaClient, v validator.Validator) repository.WebhookWorkerRepository

func NewWorkerAPIRepository 

func NewWorkerAPIRepository(client *db.PrismaClient, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, m *metered.Metered) repository.WorkerAPIRepository

func NewWorkerEngineRepository 

func NewWorkerEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, m *metered.Metered) repository.WorkerEngineRepository

func NewWorkflowEngineRepository 

func NewWorkflowEngineRepository(pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, m *metered.Metered) repository.WorkflowEngineRepository

func NewWorkflowRepository 

func NewWorkflowRepository(client *db.PrismaClient, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger) repository.WorkflowAPIRepository

func NewWorkflowRunEngineRepository 

func NewWorkflowRunEngineRepository(stepRunRepository *stepRunEngineRepository, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, m *metered.Metered, cbs ...repository.Callback[*dbsqlc.WorkflowRun]) repository.WorkflowRunEngineRepository

func NewWorkflowRunRepository 

func NewWorkflowRunRepository(client *db.PrismaClient, pool *pgxpool.Pool, v validator.Validator, l *zerolog.Logger, m *metered.Metered) repository.WorkflowRunAPIRepository

func UniqueSet added in v0.42.0 

func UniqueSet[T any](i []T, keyFunc func(T) string) map[string]struct{}

Types

type IngestBuf added in v0.49.1 

type IngestBuf[T any, U any] struct {
	// contains filtered or unexported fields
}

func NewIngestBuffer added in v0.49.1 

func NewIngestBuffer[T any, U any](opts IngestBufOpts[T, U]) *IngestBuf[T, U]

NewIngestBuffer creates a new buffer for any type T

func (*IngestBuf[T, U]) BuffItem added in v0.49.1 

func (b *IngestBuf[T, U]) BuffItem(item T) (chan *flushResponse[U], error)

func (*IngestBuf[T, U]) Start added in v0.49.1 

func (b *IngestBuf[T, U]) Start() (func() error, error)

type IngestBufOpts added in v0.49.1 

type IngestBufOpts[T any, U any] struct {
	MaxCapacity        int                                               `validate:"required,gt=0"`
	FlushPeriod        time.Duration                                     `validate:"required,gt=0"`
	MaxDataSizeInQueue int                                               `validate:"required,gt=0"`
	OutputFunc         func(ctx context.Context, items []T) ([]U, error) `validate:"required"`
	SizeFunc           func(T) int                                       `validate:"required"`
	L                  *zerolog.Logger                                   `validate:"required"`
}

type PrismaRepositoryOpt 

type PrismaRepositoryOpt func(*PrismaRepositoryOpts)

func WithCache 

func WithCache(cache cache.Cacheable) PrismaRepositoryOpt

func WithLogger 

func WithLogger(l *zerolog.Logger) PrismaRepositoryOpt

func WithMetered 

func WithMetered(metered *metered.Metered) PrismaRepositoryOpt

func WithValidator 

func WithValidator(v validator.Validator) PrismaRepositoryOpt

type PrismaRepositoryOpts 

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

type TenantBufManagerOpts added in v0.49.1 

type TenantBufManagerOpts[T any, U any] struct {
	OutputFunc func(ctx context.Context, items []T) ([]U, error) `validate:"required"`
	SizeFunc   func(T) int                                       `validate:"required"`
	L          *zerolog.Logger                                   `validate:"required"`
	V          validator.Validator                               `validate:"required"`

	FlushPeriod         *time.Duration
	FlushItemsThreshold int
}

type TenantBufferManager added in v0.49.1 

type TenantBufferManager[T any, U any] struct {
	// contains filtered or unexported fields
}

func NewTenantBufManager added in v0.49.1 

func NewTenantBufManager[T any, U any](opts TenantBufManagerOpts[T, U]) (*TenantBufferManager[T, U], error)

Create a new TenantBufferManager with generic types T for input and U for output

func (*TenantBufferManager[T, U]) BuffItem added in v0.49.1 

func (t *TenantBufferManager[T, U]) BuffItem(tenantKey string, eventOps T) (chan *flushResponse[U], error)

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.