ridu

package module
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: Sep 10, 2026 License: MIT Imports: 6 Imported by: 0

README ¶

Ridu

Ridu is a pre-1.0 Go content-management framework with an included Svelte 5 admin. Define collections, fields, access rules, hooks, and plugins in Go; Ridu derives the selected database schema and migrations, REST API, generated TypeScript contracts, Fetch SDK, and authoring interface from that one executable configuration.

[!IMPORTANT] Ridu is pre-1.0 software. Compatibility may change between minor releases, so evaluate it carefully before using it with production data. Ridu is available under the MIT License.

Ridu's embedded admin dashboard

Why Ridu

  • Go-defined content models. Ridu resolves executable Go configuration into a deterministic, versioned schema manifest.
  • One operation engine. Local Go calls, REST, the SDK, admin, tasks, and plugin transports share authorization, validation, hooks, transactions, population, and redaction.
  • One application binary. The built Svelte admin is embedded in the Go server. npm, Bun, pnpm, or Yarn is used at build time, not as a production runtime.
  • Explicit extension points. Backend plugins are compiled Go packages; admin plugins are statically registered Svelte and TypeScript modules.
  • Project tooling included. The CLI creates projects, generates contracts, manages migrations, runs development, builds releases, and installs optional coding-agent guidance.

Create a project

Open the npm initializer and choose Starter and SQLite for a service-free first run. After the wizard finishes, run the commands it prints:

npm create ridu@latest my-app
cd my-app
npm install
npm run dev

The project records npm as its package manager and pins the matching @riducms/cli version. The same flow works with bun create, pnpm create, or yarn create; the project then uses that manager for development, checks, builds, and plugin packages. Go users can instead install and run the same command directly:

go install github.com/riducms/ridu/cmd/ridu@latest
ridu new

Follow the Quickstart to create the first user and document, then read it through the generated TypeScript SDK. PostgreSQL and MongoDB setup, including existing-project wiring and production limits, is covered by the public adapter guides.

Try the source checkout

Building the source checkout requires Go 1.25 or newer and Bun 1.4.0.

git clone https://github.com/riducms/ridu.git
cd ridu
bun install --frozen-lockfile
make demo

Open http://127.0.0.1:8080/admin/login and sign in with:

  • email: editor@riducms.test
  • password: ridu-browser

The demo uses an in-memory store and resets when it stops, so it does not require PostgreSQL.

Framework contributors can exercise the current checkout's scaffold instead of the registry CLI. Choose a target directory that does not exist:

make dogfood-new TARGET=/tmp/ridu-dogfood-content
cd /tmp/ridu-dogfood-content
./.ridu/bin/ridu dev

To run the interactive Charm wizard against the current checkout, use:

make dogfood-new INTERACTIVE=1

The wizard asks where the project should live. Pass TARGET=/tmp/ridu-interactive-content as well when you want to preselect the directory and proceed directly to the template choice. Cancelling the wizard does not provision local packages or report a ready project.

Set RIDU_ACCESSIBLE=1 to use stable plain-text prompts instead of the full terminal interface. Routine CLI logs use muted short timestamps and a [ridu] scope; warnings and errors add an explicit level, and only error timestamps are bold. Set NO_COLOR (an empty value is sufficient) to disable their ANSI styling. During development Vite owns its warning/error formatting while Go server output remains identifiable by a [server] badge.

Documentation

Repository map

cmd/ridu/                    project CLI
core/                        public application contracts and runtime coordination
field/, query/, schema/      public content-model and query contracts
store/, storage/             public persistence and object-storage contracts
internal/                    framework implementation
adapters/                    official database and object-storage adapters
plugins/                     official backend and paired admin plugins
admin/                       framework-owned Svelte admin
packages/                    npm CLI plus TypeScript protocol, SDK, build, UI, and plugin contracts
migration/                   source-neutral migration building blocks
tests/, testdata/            cross-surface contracts and fixtures
website/                     public product site, guides, and API reference
playground/                  isolated migration and component-evaluation applications

The root Go package is a thin ergonomic facade. Public leaf packages remain independent of it, and production code never imports from the playground. The ownership rules contributors need are summarized in CONTRIBUTING.md.

Develop Ridu

bun install --frozen-lockfile
make check-dev
make check-fast

Use make check-dev for the ordinary edit loop. make check-fast adds generated-project contracts, real Vite integration and production frontend builds; run make check-full before handing off framework changes. Run make performance-check separately for scale and browser timing evidence. Before publishing, run make release-check; it also requires GoReleaser 2.18.0.

Read CONTRIBUTING.md before changing public contracts. The intended Go module is github.com/riducms/ridu, framework JavaScript packages use the @riducms npm scope, and the intended public site is https://riducms.com. Releases are version-coordinated across Go, npm, and official plugins; vulnerabilities should be reported through the private process in SECURITY.md.

Documentation ¶

Overview ¶

Package ridu provides the public application-authoring facade for the Ridu content-management framework.

The facade re-exports the stable authoring and application contracts from package core while keeping ordinary application imports concise. Declarative fields and queries resolve into one schema, and every document operation enters the same internal operation engine.

Index ¶

Constants ¶

View Source 
const (
	AccessAllow = core.AccessAllow
	AccessDeny  = core.AccessDeny
	AccessWhere = core.AccessWhere

	AdminPluginAPIVersion = core.AdminPluginAPIVersion
	PluginAPIVersion      = core.PluginAPIVersion

	FrameworkVersion = core.FrameworkVersion

	PluginDatabaseAdapterPostgres = core.PluginDatabaseAdapterPostgres
	PluginDatabaseAdapterSQLite   = core.PluginDatabaseAdapterSQLite

	AuthOperationLogin             = core.AuthOperationLogin
	AuthOperationLogout            = core.AuthOperationLogout
	AuthOperationRefresh           = core.AuthOperationRefresh
	AuthOperationPasswordReset     = core.AuthOperationPasswordReset
	AuthOperationEmailVerification = core.AuthOperationEmailVerification
	AuthOperationAPIKey            = core.AuthOperationAPIKey
	AuthOperationExternalStrategy  = core.AuthOperationExternalStrategy

	TaskBackoffFixed       = core.TaskBackoffFixed
	TaskBackoffLinear      = core.TaskBackoffLinear
	TaskBackoffExponential = core.TaskBackoffExponential
	TaskStateQueued        = store.TaskStateQueued
	TaskStateRunning       = store.TaskStateRunning
	TaskStateSucceeded     = store.TaskStateSucceeded
	TaskStateFailed        = store.TaskStateFailed
	TaskStateCanceled      = store.TaskStateCanceled

	TaskErrorNotRegistered = core.TaskErrorNotRegistered
	TaskErrorUnavailable   = core.TaskErrorUnavailable
	TaskErrorInvalidInput  = core.TaskErrorInvalidInput
	TaskErrorInvalidOutput = core.TaskErrorInvalidOutput
	TaskErrorNotFound      = core.TaskErrorNotFound
	TaskErrorStoreFailed   = core.TaskErrorStoreFailed
	TaskErrorLeaseLost     = core.TaskErrorLeaseLost
)
View Source 
const MaxTaskPayloadBytes = core.MaxTaskPayloadBytes

Variables ¶

This section is empty.

Functions ¶

func AbortTask ¶ 

func AbortTask(code string, cause error) error

func Execute ¶ 

func Execute(applicationConfig Config, options ...ExecuteOption) error

Execute resolves configuration, initializes plugins, and runs configured services.

func Resolve ¶ 

func Resolve(applicationConfig Config) (schema.Manifest, error)

Resolve validates executable configuration and returns its canonical manifest.

func RetryTask ¶ 

func RetryTask(code string, cause error) error

func RetryTaskAfter ¶ 

func RetryTaskAfter(code string, cause error, delay time.Duration) error

Types ¶

type APIKey ¶ 

type APIKey = core.APIKey

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type APIKeyInfo ¶ 

type APIKeyInfo = core.APIKeyInfo

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AccessCapabilities ¶ 

type AccessCapabilities = core.AccessCapabilities

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AccessContext ¶ 

type AccessContext = core.AccessContext

AccessContext gives an AccessRule the current operation, actor, submitted data, locale, and access-controlled Local API.

type AccessDecision ¶ 

type AccessDecision = core.AccessDecision

AccessDecision is the result of an AccessRule. Construct one with Allow, Deny, or Where rather than its zero value.

func Allow ¶ 

func Allow() AccessDecision

Allow authorizes an operation without adding a document filter.

func Deny ¶ 

func Deny() AccessDecision

Deny rejects an operation.

func Where ¶ 

func Where(expression query.Expression) AccessDecision

Where authorizes only documents matching expression.

type AccessDecisionKind ¶ 

type AccessDecisionKind = core.AccessDecisionKind

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AccessRule ¶ 

type AccessRule = core.AccessRule

AccessRule authorizes one collection or global operation. Assign it through CollectionAccess or GlobalAccess; returning an error stops the operation.

type AdminConfig ¶ 

type AdminConfig = core.AdminConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AdminLanguage ¶ 

type AdminLanguage = core.AdminLanguage

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AdminLocalizationConfig ¶ 

type AdminLocalizationConfig = core.AdminLocalizationConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AdminPluginMetadata ¶ 

type AdminPluginMetadata = core.AdminPluginMetadata

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AdminTimeZone ¶ 

type AdminTimeZone = core.AdminTimeZone

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AfterCommitDispatcher ¶ 

type AfterCommitDispatcher = core.AfterCommitDispatcher

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AfterCommitEffect ¶ 

type AfterCommitEffect = core.AfterCommitEffect

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type App ¶ 

type App = core.App

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

func New ¶ 

func New(applicationConfig Config, backend store.Store) (*App, error)

New builds an application runtime using backend after resolving configuration.

type AuditEvent ¶ 

type AuditEvent = core.AuditEvent

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthAccess ¶ 

type AuthAccess = core.AuthAccess

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthAccessRule ¶ 

type AuthAccessRule = core.AuthAccessRule

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthConfig ¶ 

type AuthConfig = core.AuthConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthContext ¶ 

type AuthContext = core.AuthContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthHook ¶ 

type AuthHook = core.AuthHook

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthHooks ¶ 

type AuthHooks = core.AuthHooks

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthIdentity ¶ 

type AuthIdentity = core.AuthIdentity

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthOperation ¶ 

type AuthOperation = core.AuthOperation

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthSession ¶ 

type AuthSession = core.AuthSession

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthSessionInfo ¶ 

type AuthSessionInfo = core.AuthSessionInfo

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthStrategy ¶ 

type AuthStrategy = core.AuthStrategy

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthStrategyContext ¶ 

type AuthStrategyContext = core.AuthStrategyContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type AuthStrategyResult ¶ 

type AuthStrategyResult = core.AuthStrategyResult

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type CapabilityOptions ¶ 

type CapabilityOptions = core.CapabilityOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Collection ¶ 

type Collection = core.Collection

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type CollectionAccess ¶ 

type CollectionAccess = core.CollectionAccess

CollectionAccess configures per-operation authorization for a Collection. Assign it to Collection.Access. Use Where when access to existing documents depends on their stored values.

For example: 

Access: ridu.CollectionAccess{
	Create: func(ctx ridu.AccessContext) (ridu.AccessDecision, error) {
		if ctx.Actor == nil {
			return ridu.Deny(), nil
		}
		return ridu.Allow(), nil
	},
}

type CollectionAdmin ¶ 

type CollectionAdmin = core.CollectionAdmin

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type CollectionHooks ¶ 

type CollectionHooks = core.CollectionHooks

CollectionHooks groups resource-level lifecycle callbacks. Assign it to Collection.Hooks or Global.Hooks; use BeforeChange to change stored values, AfterRead to change a response, and AfterCommit for post-commit effects.

For example: 

Hooks: ridu.CollectionHooks{
	BeforeChange: []ridu.Hook{
		func(ctx ridu.HookContext) error {
			ctx.Data["status"] = store.String("draft")
			return nil
		},
	},
}

type CollectionIndex ¶ 

type CollectionIndex = core.CollectionIndex

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type CollectionLabels ¶ 

type CollectionLabels = core.CollectionLabels

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Config ¶ 

type Config = core.Config

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ConfigTransformer ¶ 

type ConfigTransformer = core.ConfigTransformer

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type DescriptorProvider ¶ 

type DescriptorProvider = core.DescriptorProvider

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type DistinctOptions ¶ 

type DistinctOptions = core.DistinctOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type DocumentLockConfig ¶ 

type DocumentLockConfig = core.DocumentLockConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Endpoint ¶ 

type Endpoint = core.Endpoint

Endpoint declares an application-owned HTTP route on Config, Collection, or Global. Its handler must enforce any endpoint-specific authorization.

For example, inside Collection.Endpoints: 

{
	Method: http.MethodGet,
	Path:   "/:id/tracking",
	Handler: func(ctx ridu.EndpointContext) {
		fmt.Fprint(ctx.Writer, ctx.RouteParams["id"])
	},
}

type EndpointContext ¶ 

type EndpointContext = core.EndpointContext

EndpointContext gives an EndpointHandler its matched HTTP request, response writer, route parameters, actor, and access-controlled Local API.

type EndpointHandler ¶ 

type EndpointHandler = core.EndpointHandler

EndpointHandler serves one custom Endpoint by writing its response through EndpointContext.Writer.

type EndpointProvider ¶ 

type EndpointProvider = core.EndpointProvider

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ExecuteOption ¶ 

type ExecuteOption = core.ExecuteOption

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

func WithAddress ¶ 

func WithAddress(address string) ExecuteOption

WithAddress configures the HTTP listen address. The default is :8080.

func WithHandlerOptions ¶ 

func WithHandlerOptions(options HandlerOptions) ExecuteOption

WithHandlerOptions configures HTTP security, limits, and observation hooks.

func WithProjectMigrations ¶ 

func WithProjectMigrations(driver migration.ProjectDriver) ExecuteOption

WithProjectMigrations registers an adapter-owned compiled migration driver for checksum-bound application data callbacks.

func WithServerOptions ¶ 

func WithServerOptions(options ServerOptions) ExecuteOption

WithServerOptions customizes production socket and graceful-drain bounds.

func WithStore ¶ 

func WithStore(factory StoreFactory) ExecuteOption

WithStore configures the singular document-store adapter lazily.

func WithUploadStorage ¶ 

func WithUploadStorage(factory StorageFactory) ExecuteOption

WithUploadStorage configures the upload storage factory used by Execute.

type FieldCapabilities ¶ 

type FieldCapabilities = core.FieldCapabilities

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type FieldValidatorProvider ¶ 

type FieldValidatorProvider = core.FieldValidatorProvider

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type FindOptions ¶ 

type FindOptions = core.FindOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type GenerationProvider ¶ 

type GenerationProvider = core.GenerationProvider

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Global ¶ 

type Global = core.Global

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type GlobalAccess ¶ 

type GlobalAccess = core.GlobalAccess

GlobalAccess configures read and write authorization for a Global. Assign it to Global.Access. Existing singleton operations may use Where, while the first update must return Allow because there is no stored row to filter.

type GlobalAdmin ¶ 

type GlobalAdmin = core.GlobalAdmin

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type HandlerOptions ¶ 

type HandlerOptions = core.HandlerOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Hook ¶ 

type Hook = core.Hook

Hook runs during one collection or global lifecycle phase. Register hooks in CollectionHooks. An error stops the phase and rolls back an uncommitted write; AfterCommit is the exception because the write has committed and later effects still run while their errors are reported.

type HookContext ¶ 

type HookContext = core.HookContext

HookContext gives a Hook the current operation, actor, values, document, and access-controlled Local API. Which values are available depends on the phase.

type HookProvider ¶ 

type HookProvider = core.HookProvider

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ImageSize ¶ 

type ImageSize = core.ImageSize

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ImportOptions ¶ 

type ImportOptions = core.ImportOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type JoinMutationResult ¶ 

type JoinMutationResult = core.JoinMutationResult

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ListOptions ¶ 

type ListOptions = core.ListOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ListWindowOptions ¶ 

type ListWindowOptions = core.ListWindowOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type LivePreviewConfig ¶ 

type LivePreviewConfig = core.LivePreviewConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type LocalAPI ¶ 

type LocalAPI = core.LocalAPI

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Locale ¶ 

type Locale = core.Locale

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type LocaleOptions ¶ 

type LocaleOptions = core.LocaleOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type LocalizationConfig ¶ 

type LocalizationConfig = core.LocalizationConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type LoginOptions ¶ 

type LoginOptions = core.LoginOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type MutationOptions ¶ 

type MutationOptions = core.MutationOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type OperationCapabilities ¶ 

type OperationCapabilities = core.OperationCapabilities

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type OperationError ¶ 

type OperationError = core.OperationError

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PasswordPolicy ¶ 

type PasswordPolicy = core.PasswordPolicy

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PasswordResetConfig ¶ 

type PasswordResetConfig = core.PasswordResetConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PasswordResetNotification ¶ 

type PasswordResetNotification = core.PasswordResetNotification

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type Plugin ¶ 

type Plugin = core.Plugin

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginDatabaseAdapter ¶ 

type PluginDatabaseAdapter = core.PluginDatabaseAdapter

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginDatabaseContribution ¶ 

type PluginDatabaseContribution = core.PluginDatabaseContribution

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginDescriptor ¶ 

type PluginDescriptor = core.PluginDescriptor

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginEndpoint ¶ 

type PluginEndpoint = core.PluginEndpoint

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginEndpointContext ¶ 

type PluginEndpointContext = core.PluginEndpointContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginEndpointHandler ¶ 

type PluginEndpointHandler = core.PluginEndpointHandler

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginFieldType ¶ 

type PluginFieldType = core.PluginFieldType

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginFieldValidationContext ¶ 

type PluginFieldValidationContext = core.PluginFieldValidationContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginFieldValidator ¶ 

type PluginFieldValidator = core.PluginFieldValidator

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginGeneratedArtifact ¶ 

type PluginGeneratedArtifact = core.PluginGeneratedArtifact

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginGenerationContext ¶ 

type PluginGenerationContext = core.PluginGenerationContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginHookContribution ¶ 

type PluginHookContribution = core.PluginHookContribution

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginMigration ¶ 

type PluginMigration = core.PluginMigration

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginTransport ¶ 

type PluginTransport = core.PluginTransport

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PluginTransportContext ¶ 

type PluginTransportContext = core.PluginTransportContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type PreviewBreakpoint ¶ 

type PreviewBreakpoint = core.PreviewBreakpoint

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ReadinessCheck ¶ 

type ReadinessCheck = core.ReadinessCheck

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ReconcileResult ¶ 

type ReconcileResult = core.ReconcileResult

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type RequestErrorEvent ¶ 

type RequestErrorEvent = core.RequestErrorEvent

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type RequestObservation ¶ 

type RequestObservation = core.RequestObservation

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type RiduCompatibility ¶ 

type RiduCompatibility = core.RiduCompatibility

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type ServerOptions ¶ 

type ServerOptions = core.ServerOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type StorageFactory ¶ 

type StorageFactory = core.StorageFactory

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type StoreFactory ¶ 

type StoreFactory = core.StoreFactory

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskBackoff ¶ 

type TaskBackoff = core.TaskBackoff

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskContext ¶ 

type TaskContext = core.TaskContext

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskDefinition ¶ 

type TaskDefinition = core.TaskDefinition

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskEnqueueOptions ¶ 

type TaskEnqueueOptions = core.TaskEnqueueOptions

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskError ¶ 

type TaskError = core.TaskError

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskErrorCode ¶ 

type TaskErrorCode = core.TaskErrorCode

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskHandler ¶ 

type TaskHandler[Input, Output any] = core.TaskHandler[Input, Output]

type TaskOption ¶ 

type TaskOption = core.TaskOption

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

func TaskAdmissionReconciler ¶ 

func TaskAdmissionReconciler(reconcile TaskReconciler) TaskOption

func TaskQueue ¶ 

func TaskQueue(queue string) TaskOption

func TaskRetention ¶ 

func TaskRetention(retention time.Duration) TaskOption

func TaskRetries ¶ 

func TaskRetries(maxAttempts int, delay, maxDelay time.Duration, backoff TaskBackoff) TaskOption

func TaskTimeout ¶ 

func TaskTimeout(timeout time.Duration) TaskOption

type TaskReceipt ¶ 

type TaskReceipt[Output any] = core.TaskReceipt[Output]

type TaskReconciler ¶ 

type TaskReconciler = core.TaskReconciler

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskResult ¶ 

type TaskResult[Output any] = core.TaskResult[Output]

type TaskRunSummary ¶ 

type TaskRunSummary = core.TaskRunSummary

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TaskState ¶ 

type TaskState = store.TaskState

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TransportProvider ¶ 

type TransportProvider = core.TransportProvider

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type TypedTask ¶ 

type TypedTask[Input, Output any] = core.TypedTask[Input, Output]

func NewTask ¶ 

func NewTask[Input, Output any](slug string, handler TaskHandler[Input, Output], options ...TaskOption) TypedTask[Input, Output]

type UploadConfig ¶ 

type UploadConfig = core.UploadConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type UploadInput ¶ 

type UploadInput = core.UploadInput

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type VerifyEmailConfig ¶ 

type VerifyEmailConfig = core.VerifyEmailConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type VerifyEmailNotification ¶ 

type VerifyEmailNotification = core.VerifyEmailNotification

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

type VersionConfig ¶ 

type VersionConfig = core.VersionConfig

Public authoring and runtime contracts live in core. These aliases keep the root package as the ergonomic application-facing entry point.

Source Files ¶

View all Source files

Directories ¶

Path Synopsis
adapters
mongodb
Package mongodb provides Ridu's official MongoDB document store.
 Package mongodb provides Ridu's official MongoDB document store.
postgres
Package postgres provides Ridu's first official document store.
 Package postgres provides Ridu's first official document store.
sqlite
Package sqlite provides Ridu's official embedded SQLite document store.
 Package sqlite provides Ridu's official embedded SQLite document store.
storage/local
Package local provides filesystem object storage for development and single-node deployments.
 Package local provides filesystem object storage for development and single-node deployments.
storage/s3
Package s3 provides a dependency-free S3-compatible object backend.
 Package s3 provides a dependency-free S3-compatible object backend.
cmd
ridu command
Command ridu is the portable project and build orchestrator for Ridu.
 Command ridu is the portable project and build orchestrator for Ridu.
Package core owns Ridu's application contracts and runtime.
 Package core owns Ridu's application contracts and runtime.
examples
blocks/cmd/server command
This entry exposes the same executable generation and migration protocol as a generated application.
 This entry exposes the same executable generation and migration protocol as a generated application.
blocks/content
Package content defines a finite block and rich-text publishing application.
 Package content defines a finite block and rich-text publishing application.
blocks/generated
Code generated by Ridu.
 Code generated by Ridu.
blocks/render
Package render demonstrates ordinary Go rendering of generated block variants.
 Package render demonstrates ordinary Go rendering of generated block variants.
documentation/adoption
Package adoption compile-checks the public field, adapter, and plugin surfaces used throughout the adoption documentation.
 Package adoption compile-checks the public field, adapter, and plugin surfaces used throughout the adoption documentation.
documentation/custom-components/color
documentation/custom-components/color/example
documentation/custom-components/content
documentation/field-rules
documentation/go-packages/operation
documentation/go-packages/query
documentation/go-packages/store
documentation/hooks
documentation/payload-comparison/content
documentation/primitive-lists
documentation/quickstart/content
Package content contains the compile-tested model used by the public Quickstart.
 Package content contains the compile-tested model used by the public Quickstart.
Package field defines the stored values, validation, access rules, hooks, and admin presentation of fields in Ridu collections and globals.
 Package field defines the stored values, validation, access rules, hooks, and admin presentation of fields in Ridu collections and globals.
internal
adminassets
Package adminassets owns the framework admin build embedded in Ridu servers.
 Package adminassets owns the framework admin build embedded in Ridu servers.
agentdocs
Package agentdocs installs the release-owned Ridu skill bundle into generated and existing projects without overwriting user-authored instructions.
 Package agentdocs installs the release-owned Ridu skill bundle into generated and existing projects without overwriting user-authored instructions.
blocktypes
Package blocktypes assigns ordinary Blocks generated symbols from the resolved manifest.
 Package blocktypes assigns ordinary Blocks generated symbols from the resolved manifest.
cli
Package cli implements the portable Ridu command-line interface behind the thin cmd/ridu entry point.
 Package cli implements the portable Ridu command-line interface behind the thin cmd/ridu entry point.
commandrun
Package commandrun preserves cancellation identity for foreground commands.
 Package commandrun preserves cancellation identity for foreground commands.
config
Package config validates and normalizes the public authoring model into a canonical immutable schema manifest.
 Package config validates and normalizes the public authoring model into a canonical immutable schema manifest.
dogfood/admin command
Command admin runs the framework repository's admin fixture and Vite server together.
 Command admin runs the framework repository's admin fixture and Vite server together.
dogfood/new command
Command dogfood-new builds and exercises the real Ridu CLI against a local versioned module proxy.
 Command dogfood-new builds and exercises the real Ridu CLI against a local versioned module proxy.
dogfood/playground command
Command playground-ridu-hydrate restores the ignored development-only packages and CLI used by the committed generated Ridu playground.
 Command playground-ridu-hydrate restores the ignored development-only packages and CLI used by the committed generated Ridu playground.
embedded
Package embedded interprets the resolved, bounded envelope declared by a plugin.
 Package embedded interprets the resolved, bounded envelope declared by a plugin.
frameworkpackages
Package frameworkpackages publishes the framework's unpublished frontend workspaces into a generated project for local dogfood testing.
 Package frameworkpackages publishes the framework's unpublished frontend workspaces into a generated project for local dogfood testing.
frameworkproxy
Package frameworkproxy publishes a Ridu checkout to a local Go module proxy for release-path tests and manual framework dogfooding.
 Package frameworkproxy publishes a Ridu checkout to a local Go module proxy for release-path tests and manual framework dogfooding.
generate
Package generate obtains a resolved manifest from an executable project and installs generated artifacts atomically.
 Package generate obtains a resolved manifest from an executable project and installs generated artifacts atomically.
goworkspace
Package goworkspace keeps project Go commands from being captured by an unrelated enclosing workspace.
 Package goworkspace keeps project Go commands from being captured by an unrelated enclosing workspace.
httpapi
jsonlimit
Package jsonlimit validates untrusted JSON structure before application decoders allocate recursive values.
 Package jsonlimit validates untrusted JSON structure before application decoders allocate recursive values.
localization
Package localization owns locale request resolution and the logical single-locale/canonical-storage transform shared by operation engines and strict store fixtures.
 Package localization owns locale request resolution and the logical single-locale/canonical-storage transform shared by operation engines and strict store fixtures.
migrationartifact
Package migrationartifact owns atomic, immutable migration artifact files.
 Package migrationartifact owns atomic, immutable migration artifact files.
operation
pluginregistry
Package pluginregistry owns the explicit, versioned plugin installation registry used by generated Ridu applications.
 Package pluginregistry owns the explicit, versioned plugin installation registry used by generated Ridu applications.
pluginscaffold
Package pluginscaffold renders a distributable paired Ridu plugin.
 Package pluginscaffold renders a distributable paired Ridu plugin.
population
Package population owns schema-driven relationship population traversal.
 Package population owns schema-driven relationship population traversal.
postgresmigration
Package postgresmigration owns private deterministic artifact assembly that is shared by the PostgreSQL planner and the portable CLI.
 Package postgresmigration owns private deterministic artifact assembly that is shared by the PostgreSQL planner and the portable CLI.
primitivefield
Package primitivefield contains the private, shared primitive-list query rules.
 Package primitivefield contains the private, shared primitive-list query rules.
project
Package project owns the private, versioned machine protocol between the portable Ridu CLI and an application's compiled project entry.
 Package project owns the private, versioned machine protocol between the portable Ridu CLI and an application's compiled project entry.
projectfile
Package projectfile discovers and validates the structural ridu.toml file owned by a generated application.
 Package projectfile discovers and validates the structural ridu.toml file owned by a generated application.
referenceindex
Package referenceindex derives and reconciles current relationship and upload references from canonical store values.
 Package referenceindex derives and reconciles current relationship and upload references from canonical store values.
releaselicense command
Command releaselicense inventories licences for modules linked into a Go binary.
 Command releaselicense inventories licences for modules linked into a Go binary.
remotefile
Package remotefile downloads user-supplied asset URLs without allowing the server to become a proxy into loopback, private, link-local, or metadata networks.
 Package remotefile downloads user-supplied asset URLs without allowing the server to become a proxy into loopback, private, link-local, or metadata networks.
scaffold
Package scaffold renders a generated Ridu application into an atomically installed target directory.
 Package scaffold renders a generated Ridu application into an atomically installed target directory.
schemadiff
Package schemadiff compares canonical manifests for migration intent that cannot be inferred safely from a database schema alone.
 Package schemadiff compares canonical manifests for migration intent that cannot be inferred safely from a database schema alone.
teststore
Package teststore provides a strict transactional fake for operation and adapter conformance tests.
 Package teststore provides a strict transactional fake for operation and adapter conformance tests.
typescript
Package typescript generates checked TypeScript contracts from Go-owned protocol and schema constants.
 Package typescript generates checked TypeScript contracts from Go-owned protocol and schema constants.
uploads
Package migration defines Ridu's database-agnostic, reviewable migration artifact vocabulary.
 Package migration defines Ridu's database-agnostic, reviewable migration artifact vocabulary.
payload
Package payload imports a normalized Payload CMS export without coupling Ridu to Payload's database schema.
 Package payload imports a normalized Payload CMS export without coupling Ridu to Payload's database schema.
Package operation provides the values and context passed to field validators, hooks, defaults, and access rules.
 Package operation provides the values and context passed to field validators, hooks, defaults, and access rules.
plugins
formbuilder
Package formbuilder contributes Payload-familiar dynamic form definitions, submission persistence, validation, payment callbacks, and email delivery.
 Package formbuilder contributes Payload-familiar dynamic form definitions, submission persistence, validation, payment callbacks, and email delivery.
graphql
Package graphql provides Ridu's optional, manifest-derived GraphQL transport.
 Package graphql provides Ridu's optional, manifest-derived GraphQL transport.
mcp
Package mcp exposes explicitly selected Ridu content reads through Model Context Protocol without bypassing the ordinary authorization and operation engine.
 Package mcp exposes explicitly selected Ridu content reads through Model Context Protocol without bypassing the ordinary authorization and operation engine.
richtext
Package richtext provides Ridu's official versioned rich-text field plugin.
 Package richtext provides Ridu's official versioned rich-text field plugin.
seo
Package seo contributes Payload-familiar search metadata fields and a paired admin authoring experience without moving executable generators into the schema manifest.
 Package seo contributes Payload-familiar search metadata fields and a paired admin authoring experience without moving executable generators into the schema manifest.
Package plugintest provides the public backend conformance suite for Ridu plugins.
 Package plugintest provides the public backend conformance suite for Ridu plugins.
Package protocol defines stable JSON envelopes shared by Ridu's HTTP API, generated TypeScript contracts, Fetch SDK, and admin.
 Package protocol defines stable JSON envelopes shared by Ridu's HTTP API, generated TypeScript contracts, Fetch SDK, and admin.
Package query defines Ridu's transport-independent query language.
 Package query defines Ridu's transport-independent query language.
Package schema defines the immutable, versioned representation of a resolved Ridu configuration.
 Package schema defines the immutable, versioned representation of a resolved Ridu configuration.
Package storage defines the public object-storage boundary used by upload collections.
 Package storage defines the public object-storage boundary used by upload collections.
Package store defines public document-storage and transaction contracts.
 Package store defines public document-storage and transaction contracts.
conformance
Package conformance provides the reusable black-box contract suite for Ridu document-store adapters.
 Package conformance provides the reusable black-box contract suite for Ridu document-store adapters.
tests
contracts/admin_server command
Command admin_server is a deterministic browser-verification fixture for the embedded admin.
 Command admin_server is a deterministic browser-verification fixture for the embedded admin.
contracts/blockreferences
Package blockreferences supplies paired inline/reference authoring fixtures.
 Package blockreferences supplies paired inline/reference authoring fixtures.
contracts/dynamicdefaults
Package dynamicdefaults exercises server initialization through the real admin.
 Package dynamicdefaults exercises server initialization through the real admin.
contracts/embedded_plugin
Package embeddedplugin is a small structured-outline plugin used by the embedded authoring reference and cross-surface contract tests.
 Package embeddedplugin is a small structured-outline plugin used by the embedded authoring reference and cross-surface contract tests.
contracts/issuetargets
Package issuetargets exercises aggregate validators through public APIs.
 Package issuetargets exercises aggregate validators through public APIs.
contracts/live_server command
contracts/livevalidation
Package livevalidation exercises opt-in feedback using the same business rules as authoritative saves, through ordinary and plugin-owned field editors.
 Package livevalidation exercises opt-in feedback using the same business rules as authoritative saves, through ordinary and plugin-owned field editors.
contracts/primitivelists
Package primitivelists exercises ordered primitive lists through public APIs.
 Package primitivelists exercises ordered primitive lists through public APIs.
contracts/primitivelists/generated
Code generated by Ridu.
 Code generated by Ridu.
contracts/query_access
Package queryaccess exercises caller query confidentiality through the shared operation engine and REST against each real database adapter.
 Package queryaccess exercises caller query confidentiality through the shared operation engine and REST against each real database adapter.
contracts/richtext_blocks
Package richtextblocks runs the same rich-text block acceptance contract on real adapters.
 Package richtextblocks runs the same rich-text block acceptance contract on real adapters.
contracts/unifiedfields
Package unifiedfields is the shared Gate 4 generation, transport and admin fixture.
 Package unifiedfields is the shared Gate 4 generation, transport and admin fixture.
contracts/unifiedfields/generated
Code generated by Ridu.
 Code generated by Ridu.
performance/graphql_with command
performance/graphql_without command
performance/graphqlfixture
Package graphqlfixture provides the representative schema used by the optional-GraphQL memory comparison.
 Package graphqlfixture provides the representative schema used by the optional-GraphQL memory comparison.
website
tools/referencegen/goextract command
Command goextract emits the public Go declaration surface used by the website reference generator.
 Command goextract emits the public Go declaration surface used by the website reference generator.

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.