Advanced Inputs

In this section, you will find: plugin.yaml file advanced inputs. Computed Inputs and Global Inputs.

Advanced inputs allow you to apply more complex rules to inputs, assisting in the creation of Plugins.

Dependency on Advanced Inputs Between Plugins

When using advanced inputs in your Plugins, it’s important to consider how they are rendered. When creating an Application with Application and Infrastructure Plugins, the system first renders all Infrastructure Plugins. This approach ensures that all infrastructure dependencies are established beforehand.

danger

• A problem can occur when an Infrastructure Plugin with the app-allowed: true option relies on an advanced input, such as inputs globais or global-computed-inputs from an Application Plugin.

• If the system processes the Infrastructure Plugin before the Application Plugin, the global inputs from the Application Plugin will not be available yet. This can result in errors or unexpected behavior during the creation of your Application. Different Plugins types can still share advanced inputs, provided they are used to create the same Application.

• Whenever an Infrastructure Plugin depends on an advanced input, the advanced input must come from another Infrastructure Plugin.

Computed Inputs

By means of computed-inputs, it is possible to:

• Create inputs based on other inputs;
• Use the value in a Plugin that is currently being applied.

Check the example when using a title filter, the first letter of each name is transformed into an upper case letter:

spec:
  inputs:
    - label: Type your name
      name: name
      type: text

  computed-inputs:
    name_formatted: "{{ name | title }}"

Global Input

When you define global inputs inside an app (via a Plugin), any Plugin can access or modify them.

You must declare a global input via the global: true flag, check it out:

spec:
  inputs:
  - label: Commit message
    type: text
    default: example
    name: message
    required: true
    global: true

danger

To use the global property in the following inputs:

• list
• object

You must declare the global: true property only in the parent input, the others cannot be declared as global, that is, all inputs that are "children" are considered global. Example:

Example of Input of type object with global property: true

- type: object
  name: parent-object
  global: true
  label: Parent object data
    input:
      type: required-connection
      name: s3
      label: Choose s3 connection
      connection-type: aws-s3-conn

Example 1: Plugin base with global input

The base Plugin in this example, has a global input that can be used in other Plugin applications, that is, in the same app that was created with this Plugin:

tip

Global inputs are supported in the StackSpot portal. To learn more, visit Jinja usage in the StackSpot portal.

schema-version: v3
kind: plugin
metadata:
  name: global-plugin
  display-name: global-plugin
  description: Plugin that has a input from global
  version: 0.0.1
spec:
  type: app
  compatibility:
    - python
  docs:
    pt-br: docs/pt-br/docs.md
    en-us: docs/en-us/docs.md
  technologies:
    - Api
  inputs:
    - label: Project name
      type: text
      name: project_name
      default: project-name
      global: true

In the example above, as the input project_name is set as global, any value entered in it can be used by other Plugins.

Example 2: Plugin using the global input from its other Plugins

The value of a global input defined in one Plugin can be used within another Plugin. It does not need to be defined again in the plugin.yaml file.

To access the value of an input defined in a Plugin, enclose the input name in double braces "{{ ... }}" forming the expression {{ <input name> }}. Check out the example below using an input "project_name" from a Plugin, the expression will be {{ project_name }}.

tip

Global inputs are supported in the StackSpot portal. To learn more, visit Jinja usage in the StackSpot portal.

schema-version: v3
kind: plugin
metadata:
  name: global-plugin
  display-name: global-plugin
  description: Plugin that has a input from global input
  version: 0.0.1
spec:
  type: app
  compatibility:
    - python
  docs:
    pt-br: docs/pt-br/docs.md
    en-us: docs/en-us/docs.md
  technologies:
    - Api
  inputs:
    - label: Insert any text
      type: text
      name: json_body
  hooks:
    - type: edit-json
      trigger: after-render
      path: package.json
      indent: "\t"
      encoding: utf-8
      changes:
        - jsonpath: "$.name[?name = '{{ project_name }}']"
          update:
            value: |
              {
                 "name": "other-project",
                 "version": "1.2.5",
                 "bin": {
                   "other-project": "./path/to/project"
                 }
              }

The value of the input project_name defined in the Plugin is used as part of the jsonpath expression used in a Declarative Hook edit-json when applying the Plugin.

Example 3: Plugin using the global input as default value in one of its inputs

You can use the global input value to set the default value of a Plugin that will be applied after another Template (or Plugin) has set a global input:

tip

Global inputs are supported in the StackSpot portal. To learn more, visit Jinja usage in the StackSpot portal.

schema-version: v3
kind: plugin
metadata:
  name: global-plugin
  display-name: global-plugin
  description: Plugin that uses a global input as default value
  version: 0.0.1
spec:
  type: app
  compatibility:
    - python
  docs:
    pt-br: docs/pt-br/docs.md
    en-us: docs/en-us/docs.md
  technologies:
    - Api
  inputs:
    - label: Project Name
      type: text
      name: project_name
      default: project_name
      global: true

Global Computed Inputs

The global computed inputs make it possible to use computed-inputs globally in Plugins.

By means of global-computed-inputs, it is possible to:

• Use computed-inputs in a global manner;
• Reuse the input value in subsequent Plugins.

Example 1. Setting a global-computed-input in a Plugin

info

The input global-computed-inputs accepts Jinja expressions and is supported in the StackSpot portal. To learn more, visit Jinja usage in the StackSpot portal.

schema-version: v3
kind: plugin
metadata:
  name: global-computed-input-template
  display-name: global-computed-input-template
  description: Template that has a global computed input
  version: 0.0.1
spec:
  type: app
  compatibility:
    - python
  docs:
    pt-br: docs/pt-br/docs.md
    en-us: docs/en-us/docs.md
  technologies:
    - Api
  inputs:
    - label: Project name
      type: text
      name: project_name
      default: project-name
  global-computed-inputs:
    project_name_sanitized: "{{project_name|replace('-', '_')|lower}}"

The project_name_sanitized value can now be used in all subsequent Plugin applications.

Example 2. Plugin using global-computed-input value

Plugin with global-computed-inputs value. The Plugins applied next will have access to the global-computed-inputs value.

To use the project_name_sanitized value defined as global computed input in the previous Plugin, simply set it to {{project_name_sanitized}} in the file where the parse will take place:

For example, to use this value in a README.md file that would be created by the Plugin:

info

The input global-computed-inputs accepts Jinja expressions and is supported in the StackSpot portal. To learn more, visit Jinja usage in the StackSpot portal.

|_plugin.yaml
|_templates
  |_README.MD

README.md

The value project_name_sanitized is {{project_name_sanitized}}.

warning

There is no need to redefine that part in plugin.yaml.

Complete example with computed-inputs and global computed inputs

info

The input global-computed-inputs accepts Jinja expressions and is supported in the StackSpot portal. To learn more, visit Jinja usage in the StackSpot portal.

schema-version: v3
kind: plugin
metadata:
  name: my-plugin
  display-name: my-plugin
  description: Describe your plugin explaining its purpose
  version: 0.0.1
spec:
  type: app
  compatibility:
    - python
  docs:
    pt-br: docs/pt-br/docs.md
    en-us: docs/en-us/docs.md
  technologies: # Ref: https://docs.stackspot.com/create-use/create-content/yaml-files/plugin-yaml/#technologies
    - Api
  inputs:
    - label: Select the connection for your my-task-connection
      name: my-task-conn
      type: required-connection
      connection-interface-type: ecs-task-conn
    - label: Type name of your resource
      name: resource
      type: text
      required: true  #default false
      default: Client
      pattern: '([A-Z][a-z]+)+'
      help: 'Inform your resource name (e.g.: Client)'
    - label: Choose http method of new endpoint
      name: method
      type: select
      items:
        - GET
        - POST
        - PUT
        - DELETE
        - PATCH
      default: GET
      required: true
      help: 'Inform the method of the endpoint (e.g.: post or delete)'
  global-computed-inputs:
    name_formatted_global: "{{ resource | upper }}"
  computed-inputs:
    name_formatted: "{{ resource | upper }}"
  hooks:
    - type: run
      trigger: before-input
      commands:
        - echo plugin before-input!
    - type: run
      trigger: after-render
      commands:
        - echo plugin after-render!