Classes

A class representing back actions.

Special request handler for admin/batchaction

The object manages the main CMS menu. See {@link LeftAndMain::init()} for example usage.

A simple CMS menu item.

Abstract form builder for insert link form

Provides a table which displays the provided record's owners

Imports {@link Group} records by CSV upload, as defined in {@link GroupCsvBulkLoader}.

LeftAndMain is the parent class of all the two-pane views in the CMS.

Plug-ins for additional functionality in your LeftAndMain classes.

Allows CMS forms to be decorated with additional context arguments.

Allow overriding finished state for faux redirects.

Abstract interface for a class which may be used to filter the results displayed in a nested tree

Imports {@link Member} records by CSV upload, as defined in {@link MemberCsvBulkLoader}.

Parent controller for all CMS-global modals

Generates a three-pane UI for editing model classes, tabular results and edit forms.

Security section of the CMS

Delete multiple {@link Folder} records (and the associated filesystem nodes).

AssetAdmin is the 'file store' section of the CMS.

Update File dataobjects to be editable in this asset admin

Extension that updates the Popover menu of FileFormFactory.

Decorates ModalController with an insert-oembed modal

Hides File Links on the "Used On" tab when viewing files

Scaffolds a form for searching files

Empty form factory, because the defaults from AssetFormFactory was enough

History view for file editor form

For providing schema data to the client side to build a preview field with upload replacement feature

Represents a file upload field with ReactJS based frontend.

API available but currently not used, as create folder uses FormBuilder

Handles create and update

Define the return type for ReadFileUsageQueryCreator. File usage is return as an array of object with an 'id' property and 'inUseCount' property.

Represents a notice related to a graphql Action. This could be a failure, warning, or recoverable query (e.g. "are you sure you want to publish this item?")

GraphQL Query to retrieve usage count for files and folders on GraphQL request.

Handles create and update

Generate thumbnails and thumbnail links

This class provides the necessary business logic to ensure that any assets attached to a record are safely deleted, published, or protected during certain operations.

Provides a mechanism for determining the effective visibility of a set of assets (identified by filename and hash), given their membership to objects of varying visibility.

Service to help migrate File dataobjects to the new APL.

A task to manually flush InterventionBackend cache

Service to migrate legacy format thumbnails, to avoid regenerating them on demand.

Service to help identify and migrate Files that have been saved to the wrong asset store and restore them to the appropriate physical location.

SS4 and its File Migration Task changes the way in which files are stored in the assets folder, with files placed in subfolders named with partial hashmap values of the file version. This helper class goes through the HTML content fields looking for instances of image links, and corrects the link path to what it should be, with an image shortcode.

SS4 and its File Migration Task changes the way in which files are stored in the assets folder, with files placed in subfolders named with partial hashmap values of the file version. This build task goes through the HTML content fields looking for instances of image links, and corrects the link path to what it should be, with an image shortcode.

Allows you to mock a backend store in a custom directory beneath assets.

This class handles the representation of a file on the filesystem within the framework.

Permissions for root files with Can*Type = Inherit

A utility class that finds any files matching a set of rules that are present within a directory tree.

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility.

A collection of static methods for manipulating the filesystem.

Adapter for local filesystem based on assets directory

Asset store based on flysystem Filesystem as a backend

Simple Flysystem implementation of GeneratedAssetHandler for storing generated content

An adapter which does not publicly expose protected files

Represents an AbstractAdapter which exposes its assets via public urls

Represents a logical folder, which may be used to organise assets stored in the configured backend.

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility.

Represents an Image

Creates backends for images as necessary, avoiding redundant asset writes and loads

Provides image manipulation functionality.

Image_Backend

Represents a link between a dataobject parent and a file shortcode in a HTML content area

Adds tracking of links in any HTMLText fields which reference SiteTree or File items.

A helper object for extracting information about links.

Provides shortcodes for File dataobject

Class ImageShortcodeProvider

Represents a container for a specific asset.

Provides a mechanism for suggesting filename alterations to a file

Represents an abstract asset persistence layer. Acts as a backend to files.

Represents a store usable with ProtectedFileController to serve up non-direct file requests

Represents a file reference stored in a database

Basic filename renamer

Interface to define a handler for persistent generated files

Provides routing for session-whitelisted protected files

An object which may have a thumbnail url

Manages uploads via HTML forms processed by PHP, uploads to Silverstripe's default upload directory, and either creates a new or uses an existing File-object for syncing with the database.

Delete items batch action.

Publish items batch action.

Batch restore of pages

Unpublish items batch action.

The main "content" area of the CMS.

Base class for filtering the subtree for certain node statuses.

Gets all pages which have changed on stage.

Works a bit different than the other filters: Shows all pages including those deleted from stage and live.

This filter will display the SiteTree as a site visitor might see the site, i.e only the pages that is currently published.

Filters pages which have a status "Deleted".

Filters pages which have a status "Draft".

Filters pages which have a status "Removed from Draft".

The most common kind of controller; effectively a controller linked to a {@link DataObject}.

Extension to include custom page icons

ModelAsController deals with mapping the initial request to the first {@link SiteTree}/{@link ContentController} pair, which are then used to handle the request.

Utility class representing links to different views of a record for CMS authors, usually for {@link SiteTree} objects with "stage" and "live" links.

Navigator items are links that appear in the $SilverStripeNavigator bar.

Assists with selecting anchors on a given page

Provides a form factory for inserting internal page links in a HTML editor

Decorates ModalController with insert internal link

Used to edit the SiteTree->URLSegment property, and suggest input based on the serverside rules defined through {@link SiteTree->generateURLSegment()} and {@link URLSegmentFilter}.

Readonly version of a site tree URL segment field

This interface lets us set up objects that will tell us what the current page is.

A redirector page redirects when the page is visited.

Controller for the {@link RedirectorPage}.

Basic data-object representing all pages within the site tree. All page types that live within the hierarchy should inherit from this. In addition, it contains a number of static methods for querying the site tree and working with draft and published states.

Plug-ins for additional functionality in your SiteTree classes.

Represents a link between a dataobject parent and a page in a HTML content area

Adds tracking of links in any HTMLText fields which reference SiteTree or File items.

A helper object for extracting information about links.

Virtual Page creates an instance of a page, with the same fields that the original page had, but readonly.

Content side-report listing pages with broken links

Extension to provide a search interface when applied to ContentController

Standard basic search form which conducts a fulltext search on all {@link SiteTree} objects.

Updates legacy SiteTree link tracking into new polymorphic many_many relation.

Identify "orphaned" pages which point to a parent that no longer exists in a specific stage.

Class AddToCampaignHandler - handle the AddToCampaign action.

A form action to return from getCMSActions or otherwise include in a CMS Edit Form that has the right action name and CSS classes to trigger the AddToCampaignHandler.

Campaign section of the CMS

Warning: Volatile API as placeholder for standard "GridField"

Handles adding the "Add to Campaign" button to a page's secondary actions menu

This represents a collection of config keys and values.

Applies config modifications as a set of deltas on top of the middleware, instead of as modifications to the underlying list.

Basic mutable config collection stored in memory

Applies a set of user-customised modifications to config

Abstract flag-aware middleware

CLI specific request building logic

Base class invoked from CLI rather than the webserver (Cron jobs, handling email bounces).

The content negotiator performs "text/html" or "application/xhtml+xml" switching. It does this through the public static function ContentNegotiator::process(). By default, ContentNegotiator will comply to the Accept headers the clients sends along with the HTTP request, which is most likely "application/xhtml+xml" (see "Order of selection" below).

Controllers are the cornerstone of all site functionality in SilverStripe. The {@link Director} selects a controller to pass control to, and then calls {@link handleRequest()}. This method will execute the appropriate action - either by calling the action method, or displaying the action's template.

A set of static methods for manipulating cookies.

A default backend for the setting and getting of cookies

The Cookie_Backend interface for use with Cookie::$inst.

Director is responsible for processing URLs, and providing environment information.

Class to support sending emails.

Mailer objects are responsible for actually sending emails.

A class with HTTP-related helpers. Like Debug, this is more a bundle of methods than a class.

Invokes the HTTP application within an ErrorControlChain

Represents a HTTP-request, including a URL that is tokenised for parsing, and a request method (GET/POST/PUT/DELETE). This is used by {@link RequestHandler} objects to decide what to do.

Represents a response returned by a controller.

A {@link HTTPResponse} encapsulated in an exception, which can interrupt the processing flow and be caught by the {@link RequestHandler} and returned to the user.

A response which contains a streamable data source.

Indicator for a class which cannot handle requests directly, but is able to generate a delegate for those requests.

Http utility functions.

Secures requests by only allowing a whitelist of Host values

Implements the following URL normalisation rules

• redirect basic auth requests to HTTPS
• force WWW, redirect to the subdomain "www."
• force SSL, redirect to https

Handles internal change detection via etag / ifmodifiedsince headers, conditionally sending a 304 not modified if possible.

Checks whether user manual confirmation is required for HTTPRequest depending on the rules given.

Bypass for AJAX requests

A bypass for manual confirmation by user (depending on some runtime conditions)

Allows a bypass when the request has been run in CLI mode

Allows a bypass for a list of environment types (e.g. DEV, TEST, LIVE)

A rule to match a GET parameter within HTTPRequest

Allows to bypass requests of a particular HTTP method

Path aware trait for rules and bypasses

A rule for checking whether we need to protect a Request

A rule to match a particular URL

A rule to match beginning of URL

A case insensitive rule to match beginning of URL

Display execution metrics for the current request if in dev mode and execmetric is provided as a request variable.

Triggers a call to flush() on all implementors of Flushable.

HTTP Request middleware Based on https://github.com/php-fig/fig-standards/blob/master/proposed/http-middleware/middleware.md#21-psrhttpservermiddlewaremiddlewareinterface

Adds middleware support to an object.

Extends the ConfirmationMiddleware with checks for user permissions

Decorates a request handler with the HTTP Middleware pattern

This middleware will rewrite headers that provide IP and host details from an upstream proxy.

Check the request for the URL special variables.

Schedule flush operation for a following request

Implements switching user session into Test and Dev environment types

Interface that is implemented by controllers that are designed to hand control over to another controller.

Implements the "Null Object" pattern for a missing http request.

Handle the X-Pjax header that AJAX responses may provide, returning the fragment, or, in the case of non-AJAX form submissions, redirecting back to the submitter.

RSSFeed class

RSSFeed_Entry class

A request filter is an object that's executed before and after a request occurs. By returning 'false' from the preRequest method, request execution will be stopped from continuing

This class is the base class of any SilverStripe object that can be used to handle HTTP requests.

Middleware that provides back-support for the deprecated RequestFilter API.

Handles all manipulation of the session.

Generate URLs assuming that BASE_PATH is also the webroot Standard SilverStripe 3 operation

Identifies a class as a root silverstripe application

Returns the most performant combination of caches available on the system:

• PhpFilesCache (PHP 7 with opcache enabled)
• ApcuCache (requires APC) with a FilesystemCache fallback (for larger cache volumes)
• FilesystemCache if none of the above is available

Assists with building of manifest cache prior to config being available

Defines a service that can flush its cache for a list of members

Provides introspection information about the class tree.

Registers config sources via ConfigCollectionInterface

Provides extensions to this object to integrate it with standard config API methods.

Factory for silverstripe configs

Library of conversion functions, implemented as static methods.

Simple Kernel container

Allows an object to declare a set of custom methods

Consolidates access and modification of PHP global variables and settings.

Loads environment variables from .env files Loosely based on https://github.com/vlucas/phpdotenv/blob/master/src/Loader.php

Allows an object to have extensions applied to it.

Add extension that can be added to an object with {@link Object::add_extension()}.

Provides an interface for classes to implement their own flushing functionality whenever flush=1 is requested.

An AfterCallAspect is run after a method is executed

A class that proxies another, allowing various functionality to be injected.

A BeforeCallAspect is run before a method is executed.

A factory which is used for creating service instances.

A class that can be instantiated or replaced via DI

A class for creating new objects by the injector.

A simple injection manager that manages creating objects and injecting dependencies between them. It borrows quite a lot from ideas taken from Spring's configuration, but is adapted to the stateless PHP way of doing things.

Registers chained injectors

Used to locate configuration for a particular named service.

Use the SilverStripe configuration system to lookup config for a particular service.

Represents the core state of a SilverStripe application Based loosely on symfony/http-kernel's KernelInterface component

Class ClassContentRemover

A class that handles loading classes and interfaces from a class manifest instance.

A utility class which builds a manifest of all classes, interfaces and caches it.

Error handler which throws, but retains the original path context.

An extension to the default file finder with some extra filters to faciliate autoload and template manifest generation:

• Only modules with _config.php files are scanned.

Abstraction of a PHP Package. Can be used to retrieve information about SilverStripe modules, and other packages managed via composer, by reading their composer.json file.

Module manifest holder

A utility class which builds a manifest of configuration items

This object represents a single resource file attached to a module, and can be used as a reference to this to be later turned into either a URL or file path.

Helper for mapping module resources to paths / urls

Sorts an associative array of items given a list of priorities, where priorities are the keys of the items in the order they are desired.

Generate URLs for client-side assets and perform any preparation of those assets needed.

The version provider will look up configured modules and examine the composer.lock file to find the current version installed for each. This is used for the logo title in the CMS via {@link LeftAndMain::CMSVersion()}

Path manipulation helpers

Represents a class with a local cache which normally invalidates itself between requests.

Handle a callable object as a discoverer

Implements the composite over flush discoverers

Checks whether a filesystem resource has been changed since the manifest generation

Public interface for startup flush discoverers

The default flush discovery implementation

Checks the manifest cache for flush being scheduled in a previous request

Guesses location for temp folder

Backtrace helper

Interface for a generic build task. Does not support dependencies. This will simply run a chunk of code when called.

A base for bulk loaders of content into the SilverStripe database.

Encapsulates the result of a {@link BulkLoader} import (usually through the {@link BulkLoader->processAll()} method).

Class to facilitate command-line output.

CSSContentParser enables parsing & assertion running of HTML content via CSS selectors.

Class to handle parsing of CSV files, where the column headers are in the first row.

A basic HTML wrapper for stylish rendering of a developement info view.

Constraint that asserts that the array it is evaluated for has a specified subset.

Constraint for checking if a SS_List contains items matching the given key-value pairs.

Constraint for checking if a SS_List contains only items matching the given key-value pairs. Each match must correspond to 1 distinct record.

Constraint for checking if every item in a SS_List matches a given match, e.g. every Member has isActive set to true

Constraint for checking if a ViewableData (e.g. ArrayData or any DataObject) contains fields matching the given key-value pairs.

Utility class to facilitate complex CSV-imports by defining column-mappings and custom converters.

Supports debugging and core error handling.

A basic HTML wrapper for stylish rendering of a developement info view.

Handles raising an notice when accessing a deprecated method

A simple controller using DebugView to wrap up the confirmation form with a template similar to other DevelopmentAdmin endpoints and UIs

Base class for development tools.

A blueprint on how to create instances of a certain {@link DataObject} subclass.

Manages a set of database fixtures for {@link DataObject} records as well as raw database table rows.

SilverStripe-specific testing object designed to support functional testing of your web app. It simulates get/post requests, form submission, and can validate resulting HTML, looking up content by CSS selector.

This class keeps track of the available database adapters and provides a meaning of registering community built adapters in to the installer process.

Interface for database helper classes.

This is a helper class for the SS installer.

Simple controller that the installer uses to test that URL rewriting is working.

A migration task is a build task that is reversible.

A custom exporter for prettier formatting of SilverStripe specific Objects in PHPUnit's failing test messages.

Returns information about the current site instance.

Test case class for the Sapphire framework.

Manages illegal and required extensions for sapphiretest

Clears flushable / resettable objects

Cleans up and reset global env vars between tests

Handles nesting of kernel before / after tests

Disables any user configured loggers by pushing a NullHandler during PHPUnit tests.

Helper for resetting, booting, or cleaning up test state.

Cleans up leftover databases from aborted test executions (starting with ss_tmpdb) Task is restricted to users with administrator rights or running through CLI.

Files imported from SS3 might end up with broken permissions if there is a case conflict.

Migrates all 3.x file dataobjects to use the new DBFile field.

Collects i18n strings

Kernel for running unit tests

Classes that implement TestOnly are only to be used during testing

Represents a test usage session of a web-app It will maintain session-state from request to request

Wrapper around HTTPResponse to make it look like a SimpleHTTPResposne

Provides upgrade interface for bootstrapping.

Uses Symfony's YAML component to parse a YAML document (see http://yaml.org).

ErrorPage holds the content for the page of an error response.

Class ErrorPageController

Class ErrorPageControllerExtension

Class ErrorPageErrorFormatter

Class ErrorPageExtension

Class ErrorPageFileExtension

Single checkbox field.

Readonly version of a checkbox field - "Yes" or "No".

Displays a set of checkboxes as a logical group.

Base class for all fields that contain other fields.

Two masked input fields, checks for matching passwords.

Renders a text field, validating its input as a currency.

Readonly version of a {@link CurrencyField}.

Readonly version of a {@link CurrencyField}.

Abstract class for all fields without data.

Form used for editing a date string

Disabled version of {@link DateField}.

Form field used for editing date time strings.

Transformation that disables all the fields on the form.

Dropdown field, created from a select tag.

Text input field with validation for correct email format according to RFC 2822.

Lets you include a nested group of fields inside a template.

A list designed to hold form field instances.

Represents a file type which can be added to a form.

Provides operations for reading and writing uploaded files to/from {see File} dataobject instances.

Base class for all forms.

The action buttons are <input type="submit"> as well as tags.

A service which can generate a form

Represents a field in a form.

Form component which contains a castable message

Will convert a SilverStripe message type into a Bootstrap alert type

A helper class for managing {@link Form} and {@link FormField} HTML template output.

This class represents "transformations" of a form - such as making it printable or making it readonly.

Stores GridField action state on an attribute on the action and then analyses request parameters to load it back

Stores GridField action state in the session in exactly the same way it has in the past

Displays a {@link SS_List} in a grid format.

This class is is responsible for adding objects to another object's has_many and many_many relation, as defined by the {@link RelationList} passed to the {@link GridField} constructor.

This component provides a button for opening the add new form provided by {@link GridFieldDetailForm}.

Adding this class to a {@link GridFieldConfig} of a {@link GridField} adds a button row to that field.

Base interface for all components that can be added to GridField.

Encapsulates a collection of components following the {@link GridFieldComponent} interface. While the {@link GridField} itself has some configuration in the form of setters, most of the details are dealt with through components.

A simple readonly, paginated view of records, with sortable and searchable headers.

Allows editing of records contained within the GridField, instead of only allowing the ability to view records in the GridField.

Allows viewing readonly details of individual records.

Similar to {@link GridFieldConfig_RecordEditor}, but adds features to work on has-many or many-many relationships.

This class is a {@link GridField} component that adds a delete action for objects.

Provides view and edit forms at GridField-specific URLs.

Provides the entry point to editing a single record presented by the {@link GridField}.

Adds an "Export list" button to the bottom of a {@link GridField}.

GridFieldFilterHeader alters the {@link GridField} with some filtering fields in the header of each column.

Adding this class to a {@link GridFieldConfig} of a {@link GridField} adds a footer bar to that field.

Adds a delete action for the gridfield to remove a relationship from group.

GridFieldLazyLoader alters the {@link GridField} behavior to delay rendering of rows until the tab containing the GridField is selected by the user.

Adds a "level up" link to a GridField table, which is useful when viewing hierarchical data. Requires the managed record to have a "getParent()" method or has_one relationship called "Parent".

GridFieldPage displays a simple current page count summary.

GridFieldPaginator paginates the {@link GridField} list and adds controls to the bottom of the {@link GridField}.

Adds an "Print" button to the bottom or top of a GridField.

GridFieldSortableHeader adds column headers to a {@link GridField} that can also sort the columns.

A trait that makes a class able to consume and use a {@link GridFieldStateManagerInterface} implementation

Creates a unique key for the gridfield, and uses that to write to and retrieve its state from the request

Defines a class that can create a key for a gridfield and apply its state to a request, and consume state from the request

Adding this class to a {@link GridFieldConfig} of a {@link GridField} adds a header title to that field.

A button that allows a user to view readonly details of a record. This is disabled by default and intended for use in readonly {@link GridField} instances.

Groups exiting actions in the Actions column in to a menu

GridField action menu item interface, this provides data so the action will be included if there is a {see GridField_ActionMenu}

Allows GridField_ActionMenuItem to act as a link

An action is defined by two things: an action name, and zero or more named arguments.

Add a new column to the table display body, or modify existing columns.

Can modify the data list.

This class is the base class when you want to have an action that alters the state of the {@link GridField}, rendered as a button element.

A GridField manipulator that provides HTML for the header/footer rows, or f or before/after the template.

A component which is used to handle when a {@link GridField} is saved into a record.

Sometimes an action isn't enough: you need to provide additional support URLs for the {@link GridField}.

This class is a snapshot of the current status of a {@link GridField}.

Simple set of data, similar to stdClass, but without the notice-level errors.

Grouped dropdown, using optgroup tags.

A PHP version of TinyMCE's configuration, to allow various parameters to be configured on a site or section basis

A TinyMCE-powered WYSIWYG HTML editor field with image and link insertion and tracking capabilities. Editor fields are created from <textarea> tags, which are then converted with JavaScript.

Readonly version of an {@link HTMLEditorField}.

Sanitises an HTMLValue so it's contents are the elements and attributes that are whitelisted using the same configuration as TinyMCE

Generates tinymce config using a combined file generated via a standard SilverStripe {@link GeneratedAssetHandler}

Default configuration for HtmlEditor specific to tinymce

Uses the default tiny_mc_gzip.php handler

Declares a service which can generate a script URL for a given HTMLEditor config

Readonly field equivalent for literal HTML

Field that generates a heading tag.

Hidden field.

Simple label, to add extra text in your forms.

Multi-line listbox field, created from a select tag.

This field lets you put an arbitrary piece of HTML into your forms.

Read-only complement of {@link MultiSelectField}.

A form field that can save into a {@link Money} database field.

Represents a SelectField that may potentially have multiple selections, and may have a {@link ManyManyList} as a data source.

NullableField is a field that wraps other fields when you want to allow the user to specify whether the value of the field is null or not.

Text input field with validation for numeric values. Supports validating the numeric value as to the {@link i18n::get_locale()} value, or an overridden locale specific to this field.

Set of radio buttons designed to emulate a dropdown.

Password input field.

Popup form action menu for "more options"

Transformation that will make a form printable.

Class representing printable tabsets

Read-only field to display a non-editable value with a label.

Transformation that will turn a form into a readonly version of itself

Required Fields allows you to set which fields need to be present before submitting the form. Submit an array of arguments or each field as a separate argument.

Represents a {@link Form} as structured data which allows a frontend library to render it.

Represents a field that allows users to select one or more items from a list

Represents a number of fields which are selectable by a radio button that appears at the beginning of each item. Using CSS, you can configure the field to only display its contents if the corresponding radio button is selected. Each item is defined through {@link SelectionGroup_Item}.

Read-only complement of {@link DropdownField}.

Represents the base class for a single-select field

Implements a single tab in a {@link TabSet}.

Defines a set of tabs in a form.

Text input field.

TextareaField creates a multi-line text field, allowing more data to be entered than a standard text field. It creates the <textarea> tag in the form HTML.

Form field to display editable time values in an field.

The readonly class for our {@link TimeField}.

Represents a Tip which can be rendered alongside a form field in the front-end.

Declares that a form field has the ability to accept and render Tips.

Allows visibility of a group of fields to be toggled.

Dropdown-like field that allows you to select an item from a hierarchical AJAX-expandable tree.

This formfield represents many-many joins using a tree selector shown in a dropdown styled element which can be added to any form usually in the CMS.

Represents a form field which has an Upload() instance and can upload to a folder

This validation class handles all form and custom form validation through the use of Required fields. It relies on javascript for client-side validation, and marking fields after server-side validation. It acts as a visitor to individual form fields.

An AuthenticatorInterface is responsible for authenticating against a SilverStripe CMS Member from the given request data.

An authenticator using SilverStripe's BasicAuth

The authentication Handler is responsible for handling authentication requirements and providing a Member to the Manager if required, so it can be used in request contexts.

Top level controller for handling graphql requests.

Attaches itself to {see DataQuery} and records any classes that are queried within a closure context.

Adds functionality that checks a request for a token before allowing a mutation to happen. Protects against CSRF attacks

Ensures mutations use POST requests

Represents middleware for evaluating a graphql query

Allows any class to hold Member state

Class FileProvider

Class HTTPProvider

Class ConfigStringProvider

Implementations of query persistence must use this interface. At a minimum, they must be able to fetch a query given an ID.

Implementations of query persistence must use this interface. At a minimum, they must be able to fetch a query given an ID.

Throws everything, including notices, so the JSON response doesn't get corruped by E_NOTICE, E_WARN outputs.

An exception that was thrown during execution of a query

This class is responsible for taking query information from a controller, processing it through middlewares, extracting the results from the GraphQL schema, and formatting it into a suitable JSON response.

Query handlers are responsible for applying a query as a string to a Schema object and returning a result.

Provides an arbitrary state container that can be passed through the resolver chain. It is empty by default and derives no state from the actual schema

Provides base functionality to all bulk loaders. Should override the collect() method with computations that parse the include/exclude directives and return a collection of classes.

Composed with a list of bulk loaders to be executed in serial and return the aggregate result of all their collect() calls

Defines a collection of class names paired with file paths

Loads classes that have a given extension assigned to them.

Loads classes by fuzzy match (glob), relative to the root e.g. src/*.model.php

Loads classes that are in a given inheritance tree, e.g. MyApp\Models\Page

Loads classes based on fuzzy match of FQCN, e.g. App\Models*

Frontend for creating a cached registry instance based on all the qualifying subclasses.

The instance of the registry, as composed by the Registry frontend

Used for unions and interfaces to map a class instance to a type

Creates a "create" mutation for a DataObject

Defines the model that generates types, queries, and mutations based on DataObjects

Creates a delete operation for a DataObject

A utility class that handles an assortment of issues related to field access on DataObjects, particularly with case insensitivity.

A schema-aware service for DataObject model types that builds out their inheritance chain in an ORM-like way, applying inherited fields and implicitly exposing ancestral types, etc.

Utility class that abstracts away class ancestry computations and creates an inheritance "type" for a DataObject

A schema-aware services for DataObject model types that creates union types for all the members of an inheritance chain. Can also apply these unions to queries to enforce unions when return types have descendants.

A schema-aware service for DataObject model types that emulates class inheritance by capturing groups of common fields into interfaces and applying one or many interfaces to concrete model types. Also creates a "base" interface for fields common to all DataObjects (i.e. "extends DataObject" pattern)

Creates a model for a DataObject

Defines a permission checking plugin for queries. Subclasses just need to provide a resolver function

A permission checking plugin for DataLists

Defines a set of arguments that applies to a field that maps to a DBField.

Adds inheritance fields to a DataObject type, and exposes its ancestry

Ensures DataObject models merge their plugins with ancestors

Adds pagination to a DataList query

Defines the interface used by all read filters for operations

Filters for queries are registered as services and retrieved by identifiers.

A filter that selects records that partially match a keyword

A query filter that filters records by the end of a field's contents

A query filter that filters records by exact match of a keyword

A query filter that filters records by greater than comparison

A query filter that filters records by greater than or equal comparison

A query filter that filters records by the presence of a value in an array

A query filter that filters records by a less than comparison

A query filter that filters records by a less than or equal comparison

A query filter that filters records by negating an exact match

A query filter that filters records by the start of a field's content

A special type of filter that accepts list values

Adds a filter parameter to a DataObject query

Adds a sort parameter to a DataObject query

Ensures any field that ends up as ViewableData, e.g. DBField, invokes forTemplate() after resolving.

Creates a read operation for a DataObject

Creates a readOne query for a DataObject

Generic resolver for DataObjects

Creates an update operation for a DataObject

Thrown when a mutation operation fails

Thrown when an operation encounters a permissions problem, e.g. lack of read/write permissions

Captures a failure that happened within a resolver. Designed to add context to the failure, as a chain of closures in a nested query can be very hard to debug.

The primary exception thrown by the Schema and its components. Used whenever the schema is put into a state where it cannot build a valid schema.

An abstraction of a field argument

An abstraction of a field that appears on a Type abstraction

Used for a variety of classes that rely on SchemaModelInterface

A field that appears on model type

Defines a mutation created by a model

Defines a query generated by a model

Defines a generic mutation

Defines a generic query

Defines a model that provides required fields for all the types it creates

Applies an array of config to a class

A class that can store a generic array of context

For models that can provide a default set of fields

A class that is capable of expressing itself in generated code

For models that provide extra types to the schema

A plugin that applies to a Field abstraction

Used by any class that declares an identifier

Implementors of this interface provide input types back to the schema

Implementors of this interface can prevent a given set of fields from being added

A plugin that applies only to mutations created by models

Applies to an operation that was crated by a model

A plugin that applies only to queries generated by models

A plugin that only applies to types generated by models

A plugin that applies to a generic mutation

Implementors of this interface can create queries and mutations dynamically

Implementors of this interface provide a lookup for operations by identifiers

Base plugin interface. There is a lot of "duck programming" happening in this API that will go away once we have better type variance in PHP 7.4: https://wiki.php.net/rfc/covariant-returns-and-contravariant-parameters

Validates that a given plugin is acceptable for the implementing class

A plugin that is used for a generic query

Implementors of this class can create a model for a given classname, e.g. Blog -> DataObjectModel

Implementors of this interface can be models that generate types and operations

Given a name, create a SchemaStorageInterface implementation

Persists a graphql-php Schema object, and retrieves it

Implementors of this interface can make a one-time, context-free update to the schema, e.g. adding a shared Enum type

Implementors of this class that can validate that they are ready to be encoded into the schema

Any class that can represent its state as a string. Kind of like serialize, but doesn't need to support unserialization

A plugin that applies to a generic Type

Generic plugin that can be used for filter inputs

Generic plugin that can be used to add sort paramaters to a query

Generic pagination functionality for a query that can be customised in subclasses

Allows adding, loading, and sorting of plugins

A central place for all the plugins to be registered and accessed by ID

Given a stack of resolver middleware and afterware, compress it into one composed function, passing along the return value.

Default field resolver for any type

A good starting point for a resolver discovery implementation.

A resolver function that can be expressed in generated PHP code

A uniform way of referring to a resolver callable. Normalises the string/array variants

The main Schema definition. A docking station for all type, model and interface abstractions.

Encapsulates configuration required for a {@link Schema} object.

An agnostic service that builds an input type based on a given field, with nesting.

Persists a graphql schema to a json document consumable by Apollo

A readonly value object that represents a schema in its final consumable state. It knows nothing about models or operations, plugins, or all the abstractions surrounding how the schema gets defined

For the most obscure approach, hash the file names so they're completely undiscoverable.

Hashed for less discoverability, but still readable if you focus on it

Naive implementation for debugging. Allow the class file name to be the same as the class

Defines a service that can obfuscate classnames to make their files less discoverable

A type that can be expressed as generated PHP code

Abstraction for enum types

Abstraction that can express input types as code

Defines a GraphQL interface. It may seem counter-intuitive that an abstraction would inherit from the concretion, but since these are just value objects that end up getting rendered as code, an unconventional architecture is probably okay. The irrelevant fields just just ignored in rendering.

Defines an interface that is backed by a model

A type that is generated by a model

Defines a union that is backed by a model definition

Abstraction for a generic type

Uniform way of referring to a type as a string. Accepts default value syntax

Abstraction of a union type

Produce a friendly error message

Monolog-compatible error handler that will output a detailed error message to the screen.

Core error handler for a SilverStripe application

Output the error to the browser, with the given HTTP status code.

Library of static methods for manipulating arrays.

A list object that wraps around an array of objects or arrays.

Interface to provide enough information about a record to make it previewable through the CMS. It uses the record database ID, its "frontend" and "backend" links to link up the edit form with its preview.

Represents an object responsible for wrapping DB connector api

Builds a SQL query string from a SQLExpression object

Represents and handles all schema management for a database

Abstract database connectivity class.

Error class for database exceptions

MySQL connector class.

A result-set from a MySQL database (using MySQLiConnector) Note that this class is only used for the results of non-prepared statements

Builds a SQL query string from a SQLExpression object

Represents schema management object for MySQL

Provides a record-view for mysqli prepared statements

TransactionManager that executes MySQL-compatible transaction control queries

Connector for MySQL using the MySQLi method

TransactionManager decorator that adds virtual nesting support.

PDO driver database connector

A result-set from a PDO database.

A handle to a PDOStatement, with cached column metadata, and type conversion

Abstract query-result class. A query result provides an iterator that returns a map for each record of a query result.

Represents an object that is capable of controlling transactions.

Global database interface, complete with static methods.

An extension that adds additional functionality to a {@link DataObject}.

Implements a "lazy loading" DataObjectSet.

A single database record & abstract class for the data-access-model.

DataObjectInterface is an interface that other data systems in your application can implement in order to behave in a manner similar to DataObject.

Provides {@link \SilverStripe\ORM\DataObject} and database schema mapping functionality

An object representing a query of data from the DataObject's supporting database.

Allows middleware to modily finalised dataquery on a per-instance basis

Represents a subgroup inside a WHERE clause in a {@link DataQuery}

DatabaseAdmin class

Represents a signed 8 byte integer field. Do note PHP running as 32-bit might not work with Bigint properly, as it would convert the value to a float when queried from the database since the value is a 64-bit one.

Represents a boolean field.

Represents a classname selector, which respects obsolete clasess.

Apply this interface to any {@link DBField} that doesn't have a 1-1 mapping with a database field.

Represents a decimal field containing a currency amount.

Represents a date field.

Represents a date-time field.

Represents a Decimal field.

Supports double precision DB types

Class Enum represents an enumeration of a set of strings.

Single field in the database.

Represents a floating point field.

A special type Int field used for foreign keys in has_one relationships.

Represents a large text field that contains HTML content.

Represents a short text field that is intended to contain HTML content.

Classes that implement the DBIndexable interface will provide options to set various index types and index contents, which will be processed by {@link \SilverStripe\ORM\DataObjectSchema}

Represents a signed 32 bit integer field.

Locale database field, mainly used in {@link Translatable} extension.

Provides storage of a localised money object in currency and amount components.

Represents an multi-select enumeration field.

Represents a decimal field from 0-1 containing a percentage value.

A special ForeignKey class that handles relations with arbitrary class types

A special type Int field used for primary keys.

An abstract base class for the string field types (i.e. Varchar and Text)

Represents a variable-length string of up to 16 megabytes, designed to store raw text

Represents a column in the database with the type 'Time'.

Class Varchar represents a variable-length string of up to 255 characters, designed to store raw text

Represents a single year field.

Additional interface for {@link SS_List} classes that are filterable.

Base class for creating comparison filters, eg; greater than, less than, greater than or equal, etc

Matches textual content with a substring match on a text fragment leading to the end of the string.

Selects textual content with an exact match between columnname and keyword.

Filters by full-text matching on the given field.

Selects numerical/date content greater than the input

Selects numerical/date content greater than or equal to the input

Selects numerical/date content less than the input

Selects numerical/date content less than or equal to the input

Matches textual content with a LIKE '%keyword%' construct.

Base class for filtering implementations, which work together with {@link SearchContext} to create or amend a query for {@link DataObject} instances.

Matches textual content with a substring match from the beginning of the string.

Incomplete.

A list decorator that allows a list to be grouped into sub-lists by common values of a field.

Subclass of {@link DataList} representing a has_many relation.

Anything that implements HiddenClass won't be shown in user-interface elements. For example, DataObjects that implement HiddenClass won't be showing in the "new page" dropdown.

DataObjects that use the Hierarchy extension can be be organised as a hierarchy, with children and parents. The most obvious example of this is SiteTree.

Contains a set of hierarchical objects generated from a marking compilation run.

Additional interface for {@link SS_List} classes that are limitable - able to have a subset of the list extracted.

A base class for decorators that wrap around a list to provide additional functionality. It passes through list methods to the underlying list implementation.

Subclass of {@link DataList} representing a many_many relation.

ManyManyList backed by a dataobject join table

Injected into DataQuery to augment getFinalisedQuery() with a join table

Creates a map from an SS_List by defining a key column and a value column.

A decorator that wraps around a data list in order to provide pagination.

Represents a has_many list linked against a polymorphic relationship

Represents a list of updates / inserts made to a single row in a table

Represents a where condition that is dynamically generated. Maybe be stored within a list of conditions, altered, and be allowed to affect the result of the parent sql query during future execution.

Represents a SQL query for an expression which interacts with existing rows (SELECT / DELETE / UPDATE) with a WHERE clause

Object representing a SQL DELETE query.

Abstract base class for an object representing an SQL query.

Object representing a SQL INSERT query.

Object representing a SQL SELECT query.

Object representing a SQL UPDATE query.

Represents a SQL expression which may have field values assigned (UPDATE/INSERT Expressions)

Abstract representation of a DB relation field, either saved or in memory

A DataList that represents a relation.

An interface that a class can implement to be treated as a list container.

Provides a simple search engine for your site based on the MySQL FULLTEXT index.

Manages searching of properties on one or more {@link DataObject} types, based on a given set of input parameters.

Additional interface for {@link SS_List} classes that are sortable.

Throw this exception whenever unexpected data is found.

An {@link ArrayList} that represents an unsaved relation.

Exception thrown by {@link DataObject}::write if validation fails. By throwing an exception rather than a user error, the exception can be caught in unit tests and as such can be used as a successful test.

A class that combined as a boolean result with an optional list of error messages.

Base "abstract" class creating reports on your data.

Reports section of the CMS.

SS_ReportWrapper is a base class for creating report wappers.

Renderer for showing SideReports in CMSMain

A report wrapper that makes it easier to define slightly different behaviour for side-reports.

An AuthenticationHandler is responsible for providing an identity (in the form of a Member object) for a given HTTPRequest.

Abstract base class for an authentication method

Provides an interface to HTTP basic authentication.

Provides a security interface functionality within the cms

Basic confirmation form implementation.

Confirmation form handler implementation

Confirmation item is a simple data object incapsulating a single confirmation unit, its unique identifier (token), its human friendly name, description and the status whether it has already been confirmed.

Confirmation Storage implemented on top of SilverStripe Session and Cookie

Provides access to the default admin

Allows objects to enforce permissions for the "root" level, where permissions can not be tied to a particular database record.

A security group.

Represents an authentication handler that can have identities logged into & out of it.

Calculates batch permissions for nested objects for:

• canView: Supports 'Anyone' type
• canEdit
• canDelete: Includes special logic for ensuring parent objects can only be deleted if their children can be deleted also.

Provides standard permission fields for inheritable permissions

Record all login attempts through the {@link LoginForm} object.

Abstract base class for a login form

Log out form to display to users who arrive at 'Security/logout' without a CSRF token. It's preferable to link to {@link Security::logout_url()} directly - we only use a form so that we can preserve the "BackURL" if set

The member class which represents the users of the system

Provides authentication for the user within the CMS

Provides the in-cms session re-authentication form for the "member" authenticator

Standard Change Password Form

Authenticate a member pased on a session cookie

Handle login requests from MemberLoginForm

Class LogoutHandler handles logging out Members from their session and/or cookie.

Class LostPasswordForm handles the requests for lost password form generation

Handle login requests from MemberLoginForm

Authenticator for the default "member" method

Log-in form for the "member" authentication method.

Authenticate a member pased on a session cookie

Imports member records, and checks/updates duplicates based on their 'Email' property.

Keep track of users' previous passwords, so that we can check that new passwords aren't changed back to old ones.

Represents a set of Groups attached to a member.

Member Validator

Specialized subclass for disabled security tokens - always returns TRUE for token checks. Use through {@link SecurityToken::disable()}.

Allows pluggable password encryption.

Blowfish encryption - this is the default from SilverStripe 3.

Legacy implementation for SilverStripe 2.1 - 2.3, which had a design flaw in password hashing that caused the hashes to differ between architectures due to floating point precision problems in base_convert().

Uses MySQL's OLD_PASSWORD encyrption. Requires an active DB connection.

Uses MySQL's PASSWORD encryption. Requires an active DB connection.

Cleartext passwords (used in SilverStripe 2.1).

Encryption using built-in hash types in PHP.

Check if authenticated user has password expired.

This class represents a validator for member passwords.

Represents a permission assigned to a group.

Shows a categorized list of available permissions (through {@link Permission::get_codes()}).

Readonly version of a {@link PermissionCheckboxSetField} - uses the same structure, but has all checkboxes disabled.

Calculates edit / view / delete permissions for one or more objects

Throw this exception to register that a user doesn't have permission to do the given action and potentially redirect them to the log-in page. The exception message may be presented to the user, so it shouldn't be in nerd-speak.

Used to let classes provide new permission codes.

A PermissionRole represents a collection of permission codes that can be applied to groups.

A PermissionRoleCode represents a single permission code assigned to a {@link PermissionRole}.

Permission_Group class

Convenience class for generating cryptographically secure pseudo-random strings/tokens

Persists a token associated with a device for users who opted for the "Remember Me" feature when logging in.

Core authentication handler / store

Implements a basic security model

Cross Site Request Forgery (CSRF) protection for the {@link Form} class and other GET links.

SiteConfig

Root permission provider for pages in the SiteTree root

Archive admin is a section of the CMS that displays archived records from versioned objects and allows for users to restore them.

The history viewer controller replaces the {@link CMSPageHistoryController} and uses the React based {@link HistoryViewerField} to display the history for a {@link DataObject} that has the {@link Versioned} extension.

The history controller factory decides which CMS history controller to use, out of the default from the silverstripe/cms module or the history viewer controller from this module, depending on the current page type

The HistoryViewerController provides AJAX endpoints for React to enable functionality, such as retrieving the form schema.

Adds a restore action to the item edit form of ArchiveAdmin

Adds a archive view for Elemental blocks

Adds a archive view for Files

Adds a archive view for Pages

This form field is both a field object in it's own right, and a decorator for another field type.

Extension of GridFieldRestoreAction to only show action if there is a valid file

A provider of a view for the archive admin

psr-6 cache proxy for an internal cache, which provides segmentation of cache keys based on current versioned mode. This ensures that cross-stage content cannot cross-pollenate each other.

Allows injection of a psr-6 proxy over an inner cache backend.

The ChangeSet model tracks several VersionedAndStaged objects for later publication as a single atomic action

A single line in a changeset

Utility class to render views of the differences between two data objects (or two versions of the same data object).

Decorates TestSession object to update get / post requests with versioned querystring arguments.

Decorate sapphire test with versioning

Extends the see Delete CRUD scaffolder to unpublish any items first

Decorator for either a Read or ReadOne query scaffolder

Scaffolds a generic update operation for DataObjects.

Scaffolds a generic update operation for DataObjects.

Scaffolds a generic read operation for DataObjects.

Scaffolds a "rollback recursive" operation for DataObjects.

Scaffolds a generic update operation for DataObjects.

This class is a {@link GridField} component that replaces the delete action and adds an archive action for objects.

This class is a {@link GridField} component that adds a restore action for versioned objects.

Converter helpers for versioned args

Provides owns / owned_by and recursive publishing API for all objects.

Provides recursive publishable behaviour for LeftAndMain and GridFieldDetailForm_ItemRequest

Generic restore action to restore an archived item to draft

Minimum level extra fields required by extensions that are versonable

The Versioned extension allows your DataObjects to have several versions, allowing you to rollback changes and view history. An example of this is the pages used in the CMS.

Decorates a GridFieldConfig with a archive action

Extends {see GridFieldDetailForm}

Provides versioned dataobject support to {see GridFieldDetailForm_ItemRequest}

Decorates a GridFieldConfig with gridfield publishing state

Initialises the versioned stage when a request is made.

Persists versioned state between requests via querystring arguments

Applies correct stage to tables

Lets you wrap a bunch of array data, or object members, into a {@link ViewableData} object.

Resets requirements for test state

Encapsulation of an embed tag, linking to an external media source.

Abstract interface for an embeddable resource

HTML Helper class

Class representing a 'diff' between two sequences of strings.

Base class for HTML cleaning implementations.

This class handles the converting of HTML fragments between a string and a DOMDocument based representation.

Cleans HTML using the HTMLPurifier package http://htmlpurifier.org/

Format a SQL Query for better readable output in HTML or Plaintext.

Abstract interface for a class which handles shortcodes

A simple parser that allows you to map BBCode-like "shortcodes" to an arbitrary callback.

Cleans HTML using the Tidy package http://php.net/manual/en/book.tidy.php

Support class for converting unicode strings into a suitable 7-bit ASCII equivalent.

Filter certain characters from "URL segments" (also called "slugs"), for nicer (more SEO-friendly) URLs.

Requirements tracker for JavaScript and CSS.

Provides an abstract interface for minifying content

This is the exception raised when failing to parse a template. Note that we don't currently do any static analysis, so we can't know if the template will run, just if it's malformed. It also won't catch mistakes that still look valid.

This is the parser for the SilverStripe template language. It gets called on a string and uses a php-peg parser to match that string against the language structure, building up the PHP code to execute that structure as it parses

Parses a template file with an *.ss file extension.

Defines an extra set of basic methods that can be used in templates that are not defined on sub-classes of {@link ViewableData}.

This extends SSViewer_Scope to mix in data on top of what the item provides. This can be "global" data that is scope-independant (like BaseURL), or type-specific data that is layered on top cross-cut like (like $FirstLast etc).

Special SSViewer that will process a template passed as a string, rather than a filename.

This tracks the current scope for an SSViewer instance. It has three goals:

• Handle entering & leaving sub-scopes in loops and withs
• Track Up and Top
• (As a side effect) Inject data that needs to be available globally (used to live in ViewableData)

Provider for the [embed] shortcode tag used by the embedding service in the HTML Editor field.

Interface that is implemented by any classes that want to expose a method that can be called in any scope in a template.

Interface that is implemented by any classes that want to expose a method that can be called in any scope in a template that returns values dependant on the state of the iterator of the current scope.

This interface needs to be implemented by any template parser that is used in SSViewer

Contains references to any number of themes or theme directories

A class which builds a manifest of all themes (which is really just a directory called "templates")

Handles finding templates from a stack of template manifest objects.

A ViewableData object is any object that can be rendered into a template/view.

Allows you to render debug information about a {@link ViewableData} object into a template.

Locale metadata

Locales data source

Data sources for localisation strings. I.e. yml files stored within the /lang folder in any installed module.

Provides localisation of messages

Message reader. Inverse of Writer

Some arbitrary resource which expires when flush is invoked.

Loads yaml localisations across all modules simultaneously.

Implement message localisation using a symfony/translate backend

Allows serialization of entity definitions collected through {@link i18nTextCollector} into a persistent format, usually on the filesystem.

Write yml files compatible with ModuleYamlLoader

Parser that scans through a template and extracts the parameters to the _t and <%t calls

SilverStripe-variant of the "gettext" tool: Parses the string content of all PHP-files and SilverStripe templates for ocurrences of the _t() translation method. Also uses the {@link i18nEntityProvider} interface to get dynamically defined entities by executing the {@link provideI18nEntities()} method on all implementors of this interface.

Base-class for storage and retrieval of translated entities.

Dynamically provide translatable entites for the {@link i18n} logic.