sessionconfig

type SessionConfig struct {
	Enabled bool `default:"false"`
	// Backend selects the storage plugin or development intent: rdb, cookie,
	// dev-volatile, dev-persist, redis, dynamo, or firestore. General server
	// backends reach the binary through their own blank imports; cookie and both
	// development intent modes are built in. It names which server backend a
	// server-placed slot uses, never whether a slot is server-placed, which
	// RegisterSessionStore states instead.
	// The enum is what makes the per-backend sections below checkable: each of
	// them names a value of this key, and a mistyped one would hide that
	// section from the startup summary silently and forever. Generation rejects
	// a condition naming a value that is not listed here.
	Backend string `` /* 199-byte string literal not displayed */
	// Retention bounds how long the store may hold one record.
	//
	// It is not the session lifetime, which [auth] declares: an expiry states
	// how long a proof of identity stays good, and this states how long bytes
	// may sit in a table. They bound different things, so the effective record
	// lifetime is whichever is shorter.
	//
	// A server backend needs it whatever authentication says. A record with no
	// deadline is one the expiry sweep has no cutoff for, and the sweep is what
	// keeps a table bounded when sessions are abandoned rather than ended.
	Retention time.Duration `` /* 126-byte string literal not displayed */
	// Each store section below names the backend it belongs to, so a summary
	// reports the one in force rather than all seven. The enabled switch is not
	// repeated: Backend answers to it, and a condition on Backend inherits that
	// gate transitively.
	//
	// Cookie is the token cookie every backend travels under, and Keyring signs
	// and seals whatever the browser carries, which is every backend that keeps
	// state on the server. Keyring states that as a not-equal so it does not
	// have to be revisited each time a backend ships; an equal list would hide a
	// secret that is in force the first time one was forgotten.
	Cookie      SessionCookieConfig      `dependon:".enabled"`
	RDB         SessionRDBConfig         `dependon:".backend=rdb"`
	Redis       SessionRedisConfig       `dependon:".backend=redis" summary:"omit"`
	CookieStore SessionCookieStoreConfig `dependon:".backend=cookie"`
	Keyring     SessionKeyringConfig     `dependon:".backend!=cookie"`
	Dynamo      SessionDynamoConfig      `dependon:".backend=dynamo"`
	Firestore   SessionFirestoreConfig   `dependon:".backend=firestore"`
}

type SessionCookieConfig struct {
	Name     string `default:"pw_session"`
	Path     string `default:"/"`
	Domain   string
	Secure   bool   `default:"true" help:"disable only for loopback development"`
	HTTPOnly bool   `default:"true"`
	SameSite string `default:"lax"`
}

type SessionCookieStoreConfig struct {
	// Name holds the sealed record beside the token cookie.
	Name string `default:"pw_session_data" help:"cookie holding the sealed record"`
}

type SessionDynamoConfig struct {
	// Table is the declared table name, which rule:dynamodb-table-naming maps
	// onto the deployed one.
	Table string `default:"popcornweb_session" help:"declared session table name"`
	// ConsistentRead makes the first read strongly consistent and removes the
	// retry a miss otherwise pays. It costs twice the read capacity.
	ConsistentRead bool `default:"false" help:"read sessions with strong consistency"`
}

type SessionFirestoreConfig struct {
	// Kind is the entity kind. A kind belongs to the type rather than to the
	// deployment, so nothing maps it; this exists for a project that has to
	// share a database with something that already owns the name.
	Kind string `default:"popcornweb_session" help:"session entity kind"`
}

type SessionKeyringConfig struct {
	// Secret is 32 or more random bytes in base64, generated with
	// `openssl rand -base64 32`. Keep it out of the file itself outside
	// development: write "${SESSION_KEYRING_SECRET}" or set the environment
	// variable. An explicit development cookie backend gets a generated value;
	// a dev-volatile registry with no ReadOnly slots needs none. `pw doctor`
	// reports a literal in any other environment as an error.
	Secret string `secret:"mask" env:"SESSION_KEYRING_SECRET" help:"base64 secret signing and sealing everything the browser carries"`
	// PreviousSecrets keep values written before a rotation readable. They
	// never write.
	PreviousSecrets []string `secret:"mask" help:"retired secrets kept readable during a rotation"`
}

type SessionLifetimeConfig struct {
	// TTL is the absolute session lifetime.
	TTL time.Duration `default:"24h" help:"absolute session lifetime"`
	// IdleTimeout expires a session that stops being used. Zero disables it.
	IdleTimeout time.Duration `default:"0s" help:"inactivity expiry; zero disables it"`
	// RenewalInterval bounds how often an active request renews idle expiry.
	RenewalInterval time.Duration `default:"0s" help:"minimum interval between idle expiry renewals"`
}

type SessionRDBConfig struct {
	Source string `default:"middleware" help:"middleware reuses middleware.rdb; dedicated opens rdb.dsn"`
	// Group names the middleware-source connection group holding the session
	// table. Empty resolves to middleware.rdb.write_group.
	Group string `help:"connection group holding the session table"`
	DSN   string `secret:"mask" help:"dedicated session database DSN"`
	Table string `default:"popcornweb_session"`
}

type SessionRedisConfig struct {
	// DSN is a redis:// or rediss:// URL. Keep credentials out of the file
	// itself with a ${NAME} reference or SESSION_REDIS_DSN.
	DSN string `secret:"mask" env:"SESSION_REDIS_DSN" help:"redis:// or rediss:// session server"`
	// KeyPrefix isolates session keys from every other user of the server.
	KeyPrefix string `default:"pw:session:" help:"key space owned by the session store"`
	// ConnectTimeout bounds the startup ping and the per-command deadlines.
	ConnectTimeout time.Duration `default:"5s" help:"startup ping and per-command deadline"`
}