Struct AppConfig

pub struct AppConfig {

    pub domain: String,
    pub version: String,
    pub port: Option<u16>,
    pub logging: Option<LoggingConfig>,
    pub error: Option<ErrorConfig>,
    pub auth: Option<AuthConfig>,
    pub globals: Option<Vec<Global>>,
    pub flags: Option<Vec<Flag>>,
    pub content: Option<Content>,
    pub models: Option<Vec<ModelConfig>>,
    pub integrations: Option<Vec<IntegrationConfig>>,
    pub actions: Option<Vec<ActionConfig>>,
    pub assets: Option<AssetsConfig>,
    pub templates: Option<Vec<TemplateConfig>>,
}

Config definition for an Ordinary Application

Fields

domain: String

Domain name for the application to be run from the deployment environment.

version: String

Version of the site build.

port: Option<u16>

Port to be used for standalone “run” instances. Behaves as the “preferred port” when running off a deployment server, but is not a guaranteed assignment.

logging: Option<LoggingConfig>

error: Option<ErrorConfig>

Configures error handling.

Note: If not included just the error message will be sent back as text.

auth: Option<AuthConfig>

Auth config for the Ordinary application.

globals: Option<Vec<Global>>

Global constants that can be accessed from templates

flags: Option<Vec<Flag>>

Feature flags which can be referenced from templates to inform application behavior, and run experiments.

content: Option<Content>

Definitions for static content “types”/object structure that can be used to inform template/page development (i.e one might define a “post” content definition, and then create a template for their blog).

ordinary.json

{
    "content": {
        "file_path": "./content.json",
        "definitions": [
            {
                "name": "post",
                "fields": [
                    { "idx": 0, "name": "slug", "kind": "String", "indexed": true },
                    { "idx": 1, "name": "title", "kind": "String" },
                    { "idx": 2, "name": "body", "kind": "String" }
                ]
            }
        ]
    }
    "templates": [
        {
            "name": "post",
            "path": "./post.html",
            "mime": "text/html",
            "route": "/posts/{slug}",
            "content": [
                {
                    "name": "post",
                    "fields": [
                        { "name": "slug", "bind": { "Segment": { "name": "slug" } } },
                        { "name": "title" },
                        { "name": "body" }
                    ]
                }
            ]
        }
    ]
}

content.json

[
    {
        "instance_of": "post",
        "fields": [
            { "name": "slug", "value": "post1" },
            { "name": "title", "value": "My First Post" },
            { "name": "body", "value": "This is a post about stuff." },
        ]
    },
    {
        "instance_of": "post",
        "fields": [
            { "name": "slug", "value": "post2" },
            { "name": "title", "value": "My Second Post" },
            { "name": "body", "value": "This is a post about other stuff." },
        ]
    }
]

post.html

<h1>{{ post.title }}</h1>
<p>{{ post.body }}</p>

models: Option<Vec<ModelConfig>>

Definitions for the models that will be stored in the Ordinary database.

integrations: Option<Vec<IntegrationConfig>>

Definitions for the external APIs that will be integrated into the Ordinary application.

actions: Option<Vec<ActionConfig>>

IO, access and language configuration for actions that are compiled to and executed as WebAssembly modules.

assets: Option<AssetsConfig>

Specifies the asset directory and per-path configuration details for assets that require preprocessing (TypeScript, SCSS, JavaScript minification, etc.)

templates: Option<Vec<TemplateConfig>>

Configuration for the templates/pages that the application will render. Each template is compiled to a WebAssembly module which accepts runtime arguments for models/content/integrations, and can be executed on either the server or the client.

With the option to render on the client, only the result of the server query needs to be sent, in a compact, optimized, format.

Currently all rendering is happening server-side, and only HTML is being sent.

In an ideal/future state multiple modes will be supported, even up to a full ‘noscript’ config.

Trait Implementations

impl Clone for AppConfig

fn clone(&self) -> AppConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AppConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AppConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AppConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.