Livingdocs Server Config

{
  "customerId": "<customerId config>",

  "logs": "<logging config>",

  "roles": "<roles config>",

  // services
  "httpServer": "<http server config>",
  "editor": "<editor config>",
  "db": "<postgres database config>",
  "redis": "<redis database config>",

  "import": "<import config>",
  "documentMigration": "<document migration config>",

  "auth": "<authentication config>",
  "emails": "<user management emails>",

  "designLoader": "<design loader config>",
  "designs": "<designs config>",

  "documents": "<document feature config>",
  "mediaLibrary": "<media library config>",
  "documentLists": "<document list feature config>",

  "projectConfigs": "<project-config config>"

  // Configure the elasticsearch behavior
  "search": "<search config>",
  "elasticIndex": "<elasticIndex config>",

  // Interactions between server, editor and users
  "pusher": "<pusher config>",
  "pushNotifications": "<push notification config>",
  "preview": "<preview config>",
  "integrations": "<integrations config>",
  "notifications": "<notifications config>",

  // routing feature
  "routing": "<routing config>",
  "kv": "<routing storage config>"

  // plugins
  "metadataPlugins": "<metadata plugins config>"
}

customerId: 'daily-planet'

roles: ['write', 'worker'] // default: ['write', 'worker']

logs: {
  enabled: true, // default: true

  // possible log levels: 'error', 'warn', 'info', 'debug', 'trace'
  level: 'warn',

  // use `true` for development to have a formatted output
  pretty: false,

  // enable http request logs
  // (requests logs always have a log level of 'info' and will be logged
  // regardless of the configured log level)
  logRequests: true,

  // Pass custom pino formatters (these are ignored when: `pretty: true`)
  // Pino Documentation: https://github.com/pinojs/pino/blob/master/docs/api.md#formatters-object
  formatters: {

    // This example will log levels as strings instead of the default numbers
    level(label, level) {
      return { level: label };
    },
  },
}

httpServer: {
  // The http listen address
  // In case ipv6 is disabled on the host, you should use `0.0.0.0`
  host: '::',
  port: 9090,
  maxRequestBodySize: '500kb',
  xForwardedForTrustIps: 'loopback,uniquelocal,172.17.0.0/24',

  // Enable gzip compression for all responses, usually you want to do this in the loadbalancer instead
  useGzipCompression: false,

  // Serve the json formatted using
  // two spaces if set to true
  prettyJsonStringify: false,

  // Enable stack traces in error responses
  // Default: true if the env variable ENVIRONMENT incudes dev/test, false otherwise
  showStackTraces: false,

  // Optionally, instead of host and port,
  // you can use a unix socket path
  // path: '/path/to/unix.socket

  // If this config is present,
  // an https server will be started.
  // The options are passed as `https.createServer(opts)`
  https: {key, cert}
}

editor: {
  // configure the Editor Host. This is used for password reset & login urls.
  public_host: 'http://localhost:9000',
  autoSaveInterval: 3 // This defines how often the editor auto saves in seconds
}

db: {
  connectionString: 'postgres://postgres:password@localhost:5432?max=20',
  ssl: {
    rejectUnauthorized: false,
    ca: '-----BEGIN CERTIFICATE-----....',
    key: '-----BEGIN PRIVATE KEY-----...',
    cert: '-----BEGIN CERTIFICATE-----....',
  }
}
// or
db: {
  host: 'localhost',
  port: '5432',
  user: 'postgres',
  database: 'li_local',
  poolMax: 20, // pool size per process
  ssl: false
  // migrate user: Used to run database migrations
  // Gets created automatically with `livingdocs-server database create`
  migrate: {
    username: 'li_test_owner',
    password: 'something2'
  },

  // Superuser that has permissions to create the users above
  setup: {
    username: 'postgres',
    password: 'something3',
    writeRole: `role_database_write`,
    readRole: `role_database_read`
  }
}

redis: {
  // All keys in redis will be prefixed by this value
  // This can be used to prevent tests from interfering with regular usage
  prefix: 'li:develop',

  // Configure a specific redis primary, defaults to 'localhost'
  host: 'redis',
  port: 6379,
  db: 0,  // {default: 0}

  // Or configure redis sentinel
  masterName: 'livingdocs-develop',
  sentinels: [
    {host: 'sentinel1', port: 26379},
    {host: 'sentinel2', port: 26379}
  ],

  // Optional username and password
  // This will also be used for the sentinel authorization.
  username: 'string',
  password: 'string',

  // If redis is configured to support tls,
  // the `tls` object must be defined and point to
  // the certificate authority and optionally
  // to a certifcate for client side authorization.
  // Please check out the supported TLS Connect Options.
  tls: {
    ca: require.resolve('./path/to/ca.cert')
  }
}

auth: {
  // Deprecated in: release-2021-11. Please use 'accessTokenSigningKeys' instead
  accessTokenSecret: 'GpA^xLH5$qLzWcqEvZmE3imYwVf68kXa1JR5rP*NFRUyRPQRtbVwWk3bHusD',

  // The secret used to sign JWT tokens
  accessTokenSigningKeys: [
    {"crv":"Ed25519","d":"fake-private-key","x":"fake-x","kty":"OKP","kid":"211027-fmJi","alg":"EdDSA","use":"sig"}
  ],

  // The refresh interval of tokens used in the editor
  accessTokenTtl: '12h',

  // After which time a user needs to log in again
  sessionTtl: '5d',

  // How long a password reset link should be valid
  passwordResetTtl: '6h',

  // How long an email confirmation link should be valid
  accountConfirmationTtl: '3d',

  // Declares authentication strategies in livingdocs
  // Please see the connections.local configuration below
  connections: "<connections>"
}

  auth: {
+    accessTokenSigningKeys: [{"kty":"oct","k":"c29tZS1zZWNyZXQtZm9yLWhtYWMyNTYtdG9rZW4tc2lnbmluZw","kid":"","alg":"HS256","use":"sig"}]
}

auth: {
  ...,
  connections: {
    local: {
      label: 'Password',
      enabled: true,
      loginEnabled: true,
      registrationEnabled: true,
      strategy: 'li-authentication-local',
      config: {
        defaultLoginDomain: 'livingdocs.io',
        passwordResetUrl: '/reset#code={{code}}',
        // You can reject certain passwords using a list of regexes
        deniedPasswords: [
          'upfront',
          'livingd[o0][cg]s',
          'lukas',
          'nzz',
          // Reject email addresses as passwords
          '@[a-z]{2,6}\\.[chomteinf]{2,4}(.au)?$'
        ]
      }
    }
  }
}

import: {
  // Enables the consumer import job hook when set to `true`
  // To be modified in read-only server instances
  // Can also be modified removing `['worker']` role, which disables consumers
  enableConsumers: true,

  // By default the livingdocs server automatically creates incremental document ids.
  // If you want to import documents from an existing system, you can set this config
  // to allow custom document ids below the threshold.
  // Please consult the guide for more details.
  allowCustomIdsBelow: 10000,

  // Defines limits and properties for job imports
  jobs: {
    batchSize: 1000,
    maxRetries: 10,
    concurrency: 10,
    retryDelay: 1000,
    maxCpu: 80,
    documentDailyLimit: 0,
    imageDailyLimit: 0,
    videoDailyLimit: 0
  },
  // In the public API "POST api/v1/import/documents" one can pass a Webhook URI to notify the importing system when the import job is done
  // Default is a POST request to the importing system
  // With transformWebhookRequest, you can influence change that request sent to the importing system
  transformWebhookRequest ({method, url, headers}) {
    if (url.startsWith('https://some-api.com/')) {
      headers['Authorization'] = 'Bearer sometoken'
    }
    return {method, url, headers}
  }
}

documentMigration: {
  // Enables the consumer document migration hook when set to `true`
  // To be modified in read-only server instances
  // Can also be modified removing `['worker']` role, which disables consumers
  enableConsumers: true,
  // Defines scheduler limits for document migration
  scheduler: {
    batchSize: 100,
    maxRetries: 1,
    concurrency: 2
  }
}

emails: {
  transports: {
    awsEmailSender: {
      from: 'Livingdocs <noreply@livingdocs.io>',
      // You can use any nodemailer module to send emails
      // The configuration below gets passed to this module
      // See https://nodemailer.com/
      module: 'nodemailer-ses-transport',
      // for more options see the aws client config object:
      // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Config.html
      config: {
        accessKeyId: 'yourAccessKeyId',
        secretAccessKey: 'yourSecretAccessKey',
        region: 'eu-west-1',
        httpOptions: {proxy: process.env.HTTP_PROXY}
      }
    }
  },
  templates: {
    userCreated: {
      transport: 'default',
      subject: 'Welcome at Livingdocs',
      htmlTemplatePath: require.resolve('@livingdocs/server/plugins/email-templates/user_created.html'),
      attachments: {
        cid: 'logo',
        filename: 'logo.png',
        path: require.resolve('@livingdocs/server/plugins/email-templates/logo.png')
      }
    },
    passwordReset: {
      transport: 'awsEmailSender',
      subject: 'Password reset',
      htmlTemplatePath: require.resolve('@livingdocs/server/plugins/email-templates/password_reset.html'),

      // # or
      // textTemplate: 'Reset password for <%= user.name %>'
      // htmlTemplate: 'Reset password for <%= user.name %>'

      attachments: {
        cid: 'logo',
        filename: 'logo.png',
        path: require.resolve('@livingdocs/server/plugins/email-templates/logo.png')
      }
    }
  }
}

auth: {
  connections: {
    local: {
      sendNotificationIfNewDevice: true
    }
  }
}

emails: {
  templates: {
    newLoginDevice: {
      transport: 'default',
      subject: 'New device login detected',
      htmlTemplatePath: require.resolve('@livingdocs/server/plugins/email-templates/new_login_device.html'),
      attachments: [{
        cid: 'logo',
        filename: 'logo.png',
        path: require.resolve('@livingdocs/server/plugins/email-templates/logo.png')
      }]
    }
  }
}

designLoader: {
  // optional
  hostedDesigns: [
    {
      designName: 'timeline',

      // The final request for timeline design v1.0.0 will go to this url:
      // -> http://assets.livingdocs.io/timeline/1.0.0
      url: 'http://assets.livingdocs.io/timeline'
    }
  ],
  // optional
  localDesigns: [
    // path to design
    {path: '/designs/timeline/v1.1.0'}
  ],
  // optional, defaults to the local design server
  designRepository: {
    remoteHost: 'http://api.livingdocs.io'
  },
  cacheSize: 100 // optional, defaults to '20'
}

designs: {
  assets: {
    cache_expiration: 31536000,
    publicUrl: 'http://livingdocs-designs-dev.s3.amazonaws.com',
    // Storage Configuration
    storage: {
      strategy: 's3',
      prefix: 'images/' // optional, the storage key will be prefixed
      config: {
        bucket: 'livingdocs-designs-dev',
        region: 'eu-west-1',
        accessKeyId: '*****',
        secretAccessKey: '*****'
      }
    }
  }
}

documents: {
  // Enables the publish control consumers
  // To be modified in read-only server instances
  // Can also be modified removing `['worker']` role, which disables consumers
  enableConsumers: true,
  selectedImageService: 'imgix',
  imageServices: {
    imgix: {} // imageService specific configuration
  },
  paginationFindConfig: {
    default: 50, // default is the batch size
    limit: 100 // limit is the max
  },
  history: {
    anonymizeAfter: '30 days'
  },
  realtimeUpdates: {
    enabled: true, // Default: false. Deprecated in: release-2023-11.
    pollingEnabled: true, // Default: false. Added in: release-2023-11.
    pollingInterval: '1m',
    websocketsEnabled: true, // Default: false. Added in: release-2023-11.
    websocketsThrottling: '5s' // Added in: release-2023-11.
  }
}

Warning: Setting the NODE_TLS_REJECT_UNAUTHORIZED environment variable to '0' makes TLS connections and HTTPS requests insecure by disabling certificate verification.

 documentLists: {
    paginationConfig: {
      default: 300, // default is the batch size
      limit: 1000 // limit is the max.
    }
  }

secretEncryptionKeys: [
  // Encryption key used for encryption
  {"kty":"oct","k":"7U6k5S_HXSujMpr2u7YjRkZLQO6LUK2vFYFHVbfNJ_g","kid":"220824-xmBI","alg":"dir","enc":"A256GCM","use":"enc"},
  // Encryption keys used for decryption only, to support key rotations
  {"kty":"oct","k":"XY4J0qe3fkI_XrWsfKNVUl7paxltR-_KuYdS2XFmqRI","kid":"220824-DDS1","alg":"dir","enc":"A256GCM","use":"enc"},
  {"kty":"oct","k":"abBKmiI624FWw1B0yevJEI6AowC4AqDQbLkZx_pSmVM","kid":"220824-aiiA","alg":"dir","enc":"A256GCM","use":"enc"}
]

routing: {
  enabled: false,
  indexing: {
    // Enables routing indexer
    // To be modified in read-only server instances
    // Can also be modified removing `['worker']` role, which disables indexer from routing API
    enabled: true,
    debug_routes: false,
    // number of publication events to process in each batch
    batch_size: 50000, // (default: 50000)
    // routes cache update interval
    watch_interval: 1000 // (default: 1000)
  },
  redis: {
    master_check_interval: 5000 // (default: 5000) how often do we check if we're the master
  }
},
// Routes indexer
kv: {
  enabled: true,
  levelUpAdapter: 'redisdown', // (default: memdown)
  redis: {
    prefix: 'li:r',
    host: process.env.redis__host,
    port: process.env.redis__port || 6379,
    db: 0, // {default: 0}
    sentinels: process.env.redis_sentinels && JSON.parse(process.env.redis_sentinels),
    masterName: process.env.redis_masterName
  }
}

search: {
  // For more details about the configuration,
  // please consult the elasticsearch client documentation. https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/basic-config.html
  elasticsearchClient: {
    // Configures the elasticsearch search cluster
    node: 'http://localhost:9200'
    // AWS Credentials support for OpenSearch
    // You can configure any AWS Credentials provider supported by the AWS SDK credentials-provider-node
    // configuration provided: https://www.npmjs.com/package/@aws-sdk/credential-provider-node#supported-configuration
    // Please make sure to always define aws object, even if you don't use AWS credentials 
    aws: {
      accessKeyId: '*****',
      secretAccessKey: '*****',
      region: 'eu-central-1'
    }
  }

  articleDocumentIndex: 'li-local-documents',
  numberOfReplicas: 1,
  apiVersion: '8.4.3', // optional, defaults to the elasticsearch version, falls back to '8.4.3'
  log: null, // use 'trace' to debug the search feature (warning: very verbose)

  // The metadata mapping determines which metadata fields will be indexed
  // in elasticsearch. This can then be used to e.g. create search filters
  // based on metadata.
  metadataMapping: require.resolve('../some/path/metadata/es_metadata_mapping'),

  // your optional custom elasticsearch search function
  queryBuilderPlugin: require.resolve('./path/to/your-own-search-function')
}

search: {
  elasticsearchClient: {
    aws: {
      region: 'eu-central-1'
    }
  }
}

search: {
  elasticsearchClient: {
    aws: {
      region: 'eu-central-1'
    }
  }
}

// reference this file with the 'queryBuilderPlugin' property in your server config

// @param {String} searchQuery 'hello world'
// @returns {Object} Elasticsearch body.query
module.exports = function (searchQuery) {
  return {
    match: {'document.title' : searchQuery}
  }
}

// conf/environments/local.js
elasticIndex: {
  // Enables background ElasticSearch indexers
  // To be modified in read-only server instances
  // Can also be modified removing `['worker']` role, which disables consumers
  enableConsumers: true

  // If this option is configured, the custom indexes and publication index name will be prefixed.
  // We advise to configure this in case you don't use credentials per environment (dev/stage/prod).
  // The indexes are created with the following pattern: `${indexNamePrefix}-${index.handle}-index`
  indexNamePrefix: 'your-company-local',

  // The concurrency defines how many requests the livingdocs-server is doing
  // in parallel on every single process
  concurrency: 2,

  // The batchSize defines how many documents/entries should be
  // aggregated into a single elasticsearch /_bulk request
  batchSize: 100,

  // Define the maximum cpu threshold of the elasticsearch cluster
  // that pauses the elasticsearch indexing once it's exceeded.
  maxCpu: 80,

  // To support multi cluster indexing, you can declare multiple clusters.
  // By default we index into the cluster defined in `search.host` or `search.elasticsearchClient`.
  // Consult https://docs.livingdocs.io/guides/search/multi-cluster-indexing/ for more details.
  clusters: [
    {handle: 'default', node: 'https://elasticsearch:9200', useAsLivingdocsIndexTarget: true}
  ],

  // Custom indexes can be configured in case you want to
  // index documents with a custom structure and mapping.
  // Consult https://docs.livingdocs.io/guides/search/custom-index/ for more details.
  customIndexes: [
    {
      // used as identifier e.g. for the background indexing via CLI
      handle: 'my-custom-publication',

      // Reference to a file that contains a factory function to transform and index documents.
      // Please
      indexInitializationFile: require.resolve('../../app/search/my-custom-publication/init.js'),

      // You can disable a specific index by setting that flag to false
      enabled: true,

      // Overrides the elasticIndex.concurrency config for a specific index
      concurrency: 2,

      // Overrides the elasticIndex.batchSize config for a specific index
      batchSize: 5,

      // Declare an alias, so we can reindex in the background and switch it once finished
      // By default the index handle is used as alias. Use `false` to disable the alias creation.
      alias: 'my-custom-publication',

      // An object passed to the index bulk operations
      context: {projectHandle: 'your-project-handle', isPublished: true},

      //  To support multi cluster indexing, you can configure a target cluster by handle.
      // Consult https://docs.livingdocs.io/guides/search/multi-cluster-indexing/ for more details.
      clusters: ['default']
    }
  ]
},

pusher: {
  enabled: false,
  app_id: '108378',
  key: 'dda3c0ca58ed2f649ea8',
  secret: '*****',
  cluster: 'eu',
  proxy: process.env.HTTP_PROXY
}

pushNotifications: {
  enabled: true,
  firebase: {
    serverKey: '*****',

    // Params sent with each message.
    //
    // Google Firebase Docs:
    // https://firebase.google.com/docs/cloud-messaging/http-server-ref
    notificationParams: {
      // high|normal, 'high' will send message immediately
      // https://firebase.google.com/docs/cloud-messaging/concept-options
      priority: 'high',

      // ringtone played when the message is received
      sound: 'sms_alert_input.caf', // other possible value: 'sms_alert_popcorn.caf'

      // The value of the badge on the home screen app icon.
      // If not specified, the badge is not changed.
      // If set to 0, the badge is removed.
      badge: '1'
    }
  }
}

pushNotifications: {
  enabled: true,
  airship: {
      apiUrl: 'https://go.urbanairship.com'
      apiAuthKeys: [
        {
          // must be base64 encoded '<App key>:<master secret key>'
          apiAuthKey: 'SECRET',

          // must match with the platform handle
          handle: 'li-website'
        }
      ],
      deepLinks: [
        {
          // must match with the platform handle
          handle: 'li-website',

          // {articleId} will be replaced with the id from the document
          urlTemplate: 'az://artikel/{articleId}',

          // fallback Url in case the deep link doesn't work
          fallbackUrl: 'https://livingdocs.io'
        }
      ],
    deviceTypes: ['android', 'ios']
  }
}

mediaLibrary: {
  // define behavior for images in Livingdocs (upload, upload processing, storage)
  images: {
    publicUrl: 'https://livingdocs-images-dev.s3.amazonaws.com', // base url of the storage
    // Storage Configuration
    storage: {
      strategy: 's3',
      prefix: 'images/' // optional, the storage key will be prefixed
      config: {
        bucket: 'livingdocs-images-development',
        region: 'eu-central-1',
        secretAccessKey: '****',
        accessKeyId: '****'
      }
    },
    // max upload values of Livingdocs API endpoints
    uploadRestrictions: {
      maxFileSize: '15mb',
    },
    processing: {
      failOn: 'warning', // 'warning' | 'error' | 'truncated' | 'none'
      maxResolution: 24 * 1000 * 1000, // 24MP,  default 24 mega-pixels
      maxConcurrentProcesses: 5, // default 5
      lossy: {
        // max pixel width or height
        maxDimension: 6000, // default 6000
        // compression
        quality: 80 // default 80
      }
      lossless: {
        // max pixel width or height
        maxDimension: 6000, // default 6000
      },
      // optional - Convert your image during upload into another format
      convert: [
        {
          sourceFormat: 'pdf',
          targetFormat: 'png'
        }
      ]
    }
  },

  // define behavior for videos in Livingdocs (upload, storage)
  videos: {
    // must be public accessible
    publicUrl: 'https://livingdocs-videos-development.s3.amazonaws.com',  // base url of the storage
    // Storage Configuration
    storage: {
      strategy: 's3',
      prefix: 'videos/', // optional, the storage key will be prefixed
      config: {
        // the videos must be public-read to be shown in the editor
        params: {ACL: 'public-read'},
        bucket: 'livingdocs-videos-development',
        region: 'eu-central-1',
        secretAccessKey: '****',
        accessKeyId: '****'
      }
    },
    // max upload values of Livingdocs API endpoints
    uploadRestrictions: {
      maxFileSize: '100mb'
    }
  },

  // define behavior for files in Livingdocs (upload, storage)
  files: {
    publicUrl: 'https://livingdocs-files-dev.s3.amazonaws.com',  // base url of the storage
    // Storage Configuration
    storage: {
      strategy: 's3',
      prefix: 'files/', // optional, the storage key will be prefixed
      config: {
        bucket: 'livingdocs-files-dev',
        region: 'eu-central-1',
        secretAccessKey: '****',
        accessKeyId: '****'
      }
    },
    // max upload values of Livingdocs API endpoints
    uploadRestrictions: {
      allowedMimeTypes: ['application/pdf'],
      maxFileSize: '100mb'
    }
  }

  // tells the media library dashboard how many images to show on one page
  paginationSize: 25,
}

mediaLibrary: {
  images: {
    proxy: {
      url: 'https://foobar.com/images/upload'
    },
    uploadRestrictions: {
      maxFileSize: '15mb'
    }
  }
}

{
 search: {
    // Analogous to the `articleDocumentIndex` configuration
    mediaLibraryIndex: 'li-local-media-library'
  }
}

livingdocs-server elasticsearch-index --handle li-media -y

  indexing: {
    enabled: true,
    behavior: [
      {
        // the type for the index
        type: 'text',
        // when there are more than behavior with the same type, a key is needed
        key: 'labels',
        // the return value of this function will be indexed
        // it is also possible to return an array
        // default is just return the value
        getValue: (val) => { if (val.labels) return val.labels.map(obj => obj.label) }
      },
      {
        // this will return the value of the metadata property and will index it as keyword
        type: 'keyword'
      },
    ]
  },

// the Elasticsearch metadata mapping file is defined in the environment config at 'search.metadata_mapping'
    "teaserImage": {
      "properties": {
        "crops": {
          "properties": {
            "height": {
              "type": "long"
            },
            "name": {
              "type": "keyword"
            },
            "url": {
              "type": "keyword"
            },
            "width": {
              "type": "double"
            },
            "x": {
              "type": "double"
            },
            "y": {
              "type": "long"
            },
            "ratio": {
              "type": "double"
            }
          }
        },
        "height": {
          "type": "long"
        },
        "imageService": {
          "type": "keyword"
        },
        "mimeType": {
          "type": "keyword"
        },
        "originalUrl": {
          "type": "keyword"
        },
        "url": {
          "type": "keyword"
        },
        "mediaId": {
          "type": "keyword"
        },
        "width": {
          "type": "long"
        }
      }
    }

{
  handle: 'magazine',
  integrations: {
    googleVision: {
      enabled: true,
      credentials: {
        type: 'service_account',
        project_id: 'livingdocs-devel-1540279986584',
        private_key_id: 'd715e0a07dd75660cc63c55571d07f92fe20c35e',
        // eslint-disable-next-line
        private_key: `-----BEGIN PRIVATE KEY-----foo bar\n-----END PRIVATE KEY-----\n`,
        client_email: 'vision-api-dev@livingdocs-devel-1540279986584.iam.gserviceaccount.com',
        client_id: '116066780307201591107',
        auth_uri: 'https://accounts.google.com/o/oauth2/auth',
        token_uri: 'https://oauth2.googleapis.com/token',
        auth_provider_x509_cert_url: 'https://www.googleapis.com/oauth2/v1/certs',
        client_x509_cert_url: 'https://www.googleapis.com/robot/v1/metadata/x509/vision-api-dev%40livingdocs-devel-1540279986584.iam.gserviceaccount.com'
      },
      confidenceCliff: 0.7,
      language: {
        label: 'German',
        locale: 'de'
      },
      shouldDetectWeb: true
    }
  }
}

// all.js
preview: {
  enabled: true
}

liServer.registerInitializedHook(async () => {
  const previewApi = liServer.features.api('li-preview')
  const documentApi = liServer.features.api('li-documents').document
  const renderFunction = async ({documentId}) => {
  const doc = await documentApi.getLatestDocument(documentId)
    return {html: `<div><h1>${doc.title}</h1><p>This is a custom preview</p></div>`}
  }
  previewApi.registerRenderFunction(renderFunction)
})

liServer.registerInitializedHook(async () => {
  const previewApi = liServer.features.api('li-preview')
  const renderFunction = async ({documentId}) => {
    return {previewUrl: `https://website.io/article/${documentId}`}
  }
  previewApi.registerRenderFunction(renderFunction)
})

{
  integrations: {
    comyan: {
      allowed: true
    },
    googleVision: {
      allowed: true
    },
    imatrics: {
      allowed: true,
      ensureExtraction: true
    },
    retresco: {
      allowed: true,
      ensureExtraction: true
    },
    woodwingAssets: {
      allowed: true
    }
  }
}

  notifications: {
    // Enables notification feature over specified channels: slack, email
    enabled: false,
    // Enables consumer jobs for the specified channels
    // To be modified in read-only server instances
    // Can also be modified removing `['worker']` role, which disables consumers
    enableConsumers: true,
    // Defines channels to use: slack, email
    channels: {
      email: {
        enabled: false,
        fromAddress: 'noreply@livingdocs.dev'
      },
      slack: {
        enabled: false
      }
    }
  },

webhooks: {
  // Enables webhooks feature
  enabled: true,
  // Enables webhook consumer hook
  // To be modified in read-only server instances
  // Can also be modified removing `['worker']` role, which disables consumers
  enableConsumers: true
}

hugo: {
  assetPath: 'hugo.customer.com',
  resource: {
    enabled: true,
    host: 'hugo-api.customer.com',
    customer: 'yourCustomerKey'
  },
  print: {
    enabled: true,
    host: 'hugo-api-pss.customer.com',
    xmlRoot: 'articleUpload'  // XML root element for print endpoints
  }
}

// option 1: provide a folder, where all *.js files are loaded
metadataPlugins: path.resolve('./example-server/plugins/metadata')

// option 2: any requireable file can be referenced
//   If the require fails and the passed string points to a directory, we glob the whole directory for `*.js` files
//   Modules can point to other modules or schemas directly
//   Attention:
//     Relative paths are currently always resolved relative to the current working directory.
//     Therefore, either require a file, or use absolute paths if you want to load them in a module.
metadataPlugins: ['some-module', require('./another-local-module'), require.resolve('./plugins/li-text')]

// ./another-local-module.js
module.exports = [{name: 'some-plugin', ...wholePluginDeclaration}, require.resolve('./another-module')]