Backstage Scaffolder Actions Directory

steps:
  - action: fetch:plain
    id: fetch-plain
    name: Fetch plain
    input:
      url: ./plain

steps:
  - action: fetch:plain
    id: fetch-plain
    name: Fetch plain
    input:
      url: ./plain
      targetPath: fetched-data

steps:
  - action: fetch:plain:plus
    id: fetch-plain
    name: Fetch plain
    input:
      commonParams:
        targetPath: ./
      sources:
        - url: https://github.com/backstage/community/tree/main/backstage-community-sessions/assets

steps:
  - action: fetch:plain:plus
    id: fetch-plain
    name: Fetch plain
    input:
      sources:
        - url: https://github.com/backstage/community/tree/main/backstage-community-sessions/assets
          targetPath: fetched-data

steps:
  - action: fetch:plain:file
    id: fetch-plain-file
    name: Fetch plain file
    input:
      url: ./plain.json

steps:
  - action: fetch:plain:file:plus
    id: fetch-files
    name: Fetch files
    input:
      commonParams:
        targetPath: ./downloads
      files:
        - url: https://github.com/backstage/community/tree/main/backstage-community-sessions/assets/test.json

steps:
  - action: fetch:plain:file:plus
    id: fetch-files
    name: Fetch files
    input:
      files:
        - url: https://github.com/backstage/community/tree/main/backstage-community-sessions/assets/test.json
          targetPath: fetched-data

steps:
  - action: fetch:template
    id: fetch-template
    name: Fetch template
    input:
      url: ./template
      values:
        name: ${{ parameters.name }}

## ${{ values.name }} service

This is a service Readme example. Please update me.

steps:
  - action: fetch:template
    id: fetch-template
    name: Fetch template
    input:
      url: ./template
      targetPath: fetched-data
      values:
        name: ${{ parameters.name }}

steps:
  - action: fetch:template
    id: fetch-template
    name: Fetch template
    input:
      url: ./template
      copyWithoutRender:
        - README.md
        - src/**.ts
      values:
        name: ${{ parameters.name }}

steps:
  - action: fetch:template
    id: fetch-template
    name: Fetch template
    input:
      url: ./template
      templateFileExtension: true
      values:
        name: ${{ parameters.name }}

steps:
  - action: fetch:template:plus
    id: fetch-multiple-templates
    name: Fetch templates
    input:
      commonParams:
        cookiecutterCompat: true
      templates: 
        - url: ./template
          values:
            name: ${{ parameters.name }}
      

steps:
  - action: fetch:template:file
    id: fetch-template-file
    name: Fetch template file
    input:
      url: './skeleton.txt'
      targetPath: './target/skeleton.txt'
      values:
        name: 'test-project'
        count: 1234
        itemList: ['first', 'second', 'third']

steps:
  - id: fetch-base
    name: Fetch Base
    action: fetch:rails
    input:
      url: ./template
      values:
        name: ${{ parameters.name }}
        owner: ${{ parameters.owner }}
        system: ${{ parameters.system }}
        railsArguments: ${{ parameters.railsArguments }}

steps:
  - action: http:backstage:request
    id: http-request
    name: Create a thing on the acme service
    input:
      method: GET
      path: '/proxy/snyk/org/<some-org>/project/<some-project-id>'

steps:
  - action: http:backstage:request
    id: http-request
    name: Create a thing on the acme service
    input:
      method: POST
      path: '/proxy/acme/thing'
      params:
        state: 'bar'

steps:
  - action: http:backstage:request
    id: http-request
    name: Create a thing on the acme service
    input:
      method: GET
      path: '/proxy/circleci/api/projects'
    headers:
      Accept: 'application/json'

steps:
  - action: http:backstage:request
    id: http-request
    name: Create a thing on the acme service
    input:
      method: POST
      path: '/api/proxy/acme/thing'
      body: 'thingname=abc1'

steps:
  - action: http:backstage:request
    id: http-request
    name: Create a thing on the acme service
    input:
      method: POST
      path: '/api/proxy/acme/thing'
      headers:
        'Content-Type': 'application/json'
      body:
        thingname: 'foo'

steps:
  - action: debug:log
    id: debug-log
    name: Log Hello World
    input:
      message: 'Hello, World!'

steps:
  - action: debug:fs:read:plus
    id: debug-fs-read
    name: Read files
    input:
      files:
        - ./catalog-info.yaml
        - some-file.txt

steps:
  - action: fs:delete
    id: delete-filds
    name: Delete files
    input:
      files:
        - files/deleteme
        - otherfiletodelete

steps:
  - action: fs:rename
    id: rename-files
    name: Rename files
    input:
      files:
        - from: copyfrom
          to: copyto
        - from: copyfrom1
          to: copyto1

steps:
  - action: fs:rename:plus
    id: renameFiles
    name: Rename files
    input:
      commonParams:
        overwrite: true
      files:
        - from: file1.txt
          to: file1Renamed.txt
          overwrite: false
        - from: file2.txt
          to: file2Renamed.txt
          overwrite: false
        - from: file3.txt
          to: file3Renamed.txt

steps:
  - id: Replace text in file
    name: Replace
    action: roadiehq:utils:fs:replace
    input:
      files:
        - file: './file.1'
          find: 'i_want_to_replace_this'
          replaceWith: ${{ parameters.templated_text }}

spec:
  owner: roadie
  type: service
  parameters:
    - title: Path
      properties:
        path:
          title: Path to the file
          type: string
          description: The path you want to get on your backstage instance
        parser:
          type: 'string'
          enum: ['yaml', 'json', 'multiyaml']

  steps:
    - id: roadiehq-utils-fs-parse
      name: backstage request
      action: roadiehq:utils:fs:parse
      input:
        path: ${{ parameters.path }}
        parser: ${{ parameters.parser }}

steps:
  - id: create
    name: Create file
    action: roadiehq:utils:fs:write
    input:
      path: foo
      content: bar

steps:
  - id: append
    name: Append to file
    action: roadiehq:utils:fs:append
    input:
      path: foo
      content: bar

steps:
  - id: merge
    name: JSON merge
    action: roadiehq:utils:merge
    input:
      path: foo
      content: bar
      options:
        noArrayIndent: true

steps:
  - id: zip
    name: Zip the workspace
    action: roadiehq:utils:zip
    input:
      path: ./error_logs.txt
      outputPath: ./error_logs.zip

steps:
  - action: zip:decompress:plus
    id: zip-decompress
    name: Decompress multiple files.
    input:
      commonParams:
        encoding: file
      sources:
        - content: ./compressed-1.zip
          destination: ./tmp.zip-1/
        - content: ./compressed-2.zip
          destination: ./tmp.zip-2/

steps:
  - action: glob:plus
    id: glob
    name: List files
    input:
      patterns:
        - "**/*.y[a?]ml"

steps:
  - action: json
    id: json-parse
    name: Parse Json files
    input:
      commonParams:
        encoding: raw
      sources:
        - content: '{"key": "value"}'

steps:
  - id: roadiehq-utils-serialize-json
    name: serialize json
    action: roadiehq:utils:serialize:json
    input:
      data: { a: "a", b: { c: "c" } }
      replacer:
        - a
        - b
        - c
      space: 1

steps:
  - action: xml
    id: xml-parse
    name: Parse xml files
    input:
      commonParams:
        encoding: raw
      sources:
        - content: "<books><book>nature calls</book></books>"

steps:
  - action: YAML_ID
    id: yaml-parse
    name: Parse yaml files
    input:
      commonParams:
        encoding: raw
      sources:
        - content: |
            key: value
        - content: |
            anotherkey: another value

steps:
  - id: roadiehq-utils-serialize-yaml
    name: serialize yaml
    action: roadiehq:utils:serialize:yaml
    input:
      data: { 'foo': 'bar' }
      options:
        noArrayIndent: true

steps:
  - id: transform
    name: Transform with jsonata
    action: roadiehq:utils:jsonata
    input:
      data: { users: [{ email: '[email protected]', name: 'a' }] }
      expression: 'users[0].email'

steps:
  - id: transform
    name: Transform YAML
    action: roadiehq:utils:jsonata:yaml:transform
    input:
      path: a/b/test.txt
      expression: <JSONata expression to perform on the input>
      options:
        noArrayIndent: true

steps:
  - id: transform
    name: Transform JSON
    action: roadiehq:utils:jsonata:json:transform
    input:
      path: a/b/test.json
      expression: 'users[0]'
      as: 'object'

steps:
  - id: transform
    name: Transform JSON
    action: roadiehq:utils:jsonata:json:transform
    input:
      path: a/b/test.json
      expression: 'users[0]'
      as: 'string'
      replacer:
        - email
        - name
        - prefix
      space: 1

    - id: merge-files
      name: Merge files
      action: json:merge-file
      input:
        inputFile: "file-1.json"
        outputFileName: results.json
        outputFilePath: updated
        jsonMergeOptions:
          defaultArrayMergeOperation: "concat"

    - id: merge-files
      name: Merge files
      action: json:merge-file
      input:
        inputFiles: ['file-1.json', 'file-2.json']
        outputFileName: result.json
        outputFilePath: updated
        jsonMergeOptions:
          defaultArrayMergeOperation: "concat"

steps:
  - id: merge
    name: JSON merge
    action: json:merge
    input:
      path: 'package.json'
      content: 
        engines:
          node: '18'

steps:
  - id: merge
    name: JSON merge
    action: roadiehq:utils:json:merge
    input:
      path: 'package.json'
      mergeArrays: true
      matchFileIndent: true
      content: 
        workspaces: 
          packages: 
           - 'packages/*'
           - 'plugins/*'

Defines a workflow step that processes regex values by replacing instances of "dog" with "monkey" in the provided input value.

##### **Outputs**
| Key        | Description                                                            | Type     |
|------------|------------------------------------------------------------------------|----------|
| `pattern`  | A validated regex pattern that can be passed to the RegExp constructor  | `string` |
| `flags`    | A validated set of flags that modify regex behavior                    | `array`  |
| `values`   | Validated key-value pairs of regex input                               | `array`  |

##### **Links**
- [Code](https://github.com/janus-idp/backstage-plugins/blob/main/plugins/regex-actions/src/actions/regex/replace.ts)
- [npm package](https://www.npmjs.com/package/@janus-idp/backstage-scaffolder-backend-module-regex)

-----


#### `regex:fs:replace:plus`
Enable regex-based search and replacement across files using glob patterns.

##### **Inputs**
| **Key**         | **Description**                                                             | **Type**    | **Example** |
|-----------------|-----------------------------------------------------------------------------|-------------|-------------|
| `pattern`*       | Regex expression to evaluate in file contents from `file`.                  | `string`    |             |
| `glob` *         | Expression glob to find files to evaluate                                   | `string`    |             |
| `replacement`*   | Replacement expression based on the `pattern` field                         | `string`    |             |
| `flags`         | Regex flags like d, g, i, m, s, u, v or y (optional)                        | `string`    |             |

##### **Examples**
Replace in files using Regex and Glob

```yaml
steps:
  - action: regex:fs:replace:plus
    id: regex-fs-replace
    name: Replace in files
    input:
      glob: "**/*.y[a?]ml"
      pattern: a
      replacement: b
      flags: g

steps:
  - action: regex:fs:replace:plus
    id: regex-fs-replace
    name: Append spring-kafka
    input:
      pattern: ([\t ]+)</dependencies>
      glob: pom.xml
      replacement: |-
        $1	<dependency>
        $1		<!-- added from backstage -->
        $1		<groupId>org.springframework.kafka</groupId>
        $1		<artifactId>spring-kafka</artifactId>
        $1	</dependency>
        $1</dependencies>

steps:
  - action: uuid:v4:gen:plus
    id: uuid-v4-gen
    name: UUID gen
    input:
      amount: 3

steps:
  - action: vars:plus
    id: reusable-vars
    name: Proxy vars
    input:
      foo: my-prefixed-${{ parameters.name | lower }}-foo
      bar: bar-${{ parameters.value | lower }}

steps:
  - action: catalog:register
    id: register-with-catalog
    name: Manually register with the catalog
    input:
      catalogInfoUrl: https://github.com/RoadieHQ/sample-service/blob/master/catalog-info-1.yaml
      # optional: false # default

steps:
  - action: catalog:register
    id: register-with-catalog
    name: Manually register with the catalog
    input:
      repoContentsUrl: ${{ steps["publish-repository"].output.repoContentsUrl }}
      # catalogInfoPath: catalog-info.yaml # default
      # optional: false # default

steps:
  - action: catalog:register:plus
    id: register-with-catalog
    name: Register with the catalog
    input:
      infos:
        - catalogInfoUrl: http://github.com/backstage/backstage/blob/master/catalog-info.yaml

steps:
  - action: catalog:write
    id: create-catalog-info-file
    name: Create catalog file
    input:
      entity:
        apiVersion: backstage.io/v1alpha1
        kind: Component
        metadata:
          name: test
          annotations: {}
        spec:
          type: service
          lifecycle: production
          owner: default/owner

steps:
  - action: catalog:write
    id: create-catalog-info-file
    name: Create catalog file
    input:
      filePath: '.backstage/catalog-info.yaml'
      entity:
        apiVersion: backstage.io/v1alpha1
        kind: Component
        metadata:
          name: test
          annotations: {}
        spec:
          type: service
          lifecycle: production
          owner: default/owner

steps:
  - action: catalog:fetch
    id: catalog-entity-fetch
    name: Fetch Catalog Entity
    input:
      entityRef: component:default/customer-service

steps:
  - action: catalog:fetch
    id: catalog-entity-fetch
    name: Fetch Catalog Entity
    input:
      entityRef: component:default/customer-service

...
parameters:
  properties:
    entity:
      type: string
      ui:field: EntityPicker
steps:
  - action: catalog:fetch
    id: catalog-entity-fetch
    name: Fetch Catalog Entity
    input:
      entityRef: ${{ parameters.entity }}

steps:
  - action: catalog:query:plus
    id: query-in-catalog
    name: Query in catalog
    input:
      queries:
        - limit: 2
          fields:
            - metadata.name
          filter:
            metadata.annotations.backstage.io/template-origin: template:default/java-api
            relations.dependsOn: ${{ parameters.component_ref }}

steps:
  - action: catalog:relation:plus
    id: query-in-relations
    name: Query in relations
    input:
      queries:
        - relations:
            - type: apiProvidedBy
              targetRef: component/default:customers-service
            - type: ownedBy
              targetRef: group/default:dream-devs
          optional: true
          relationType: apiProvidedBy

steps:
  - id: timestamp
    name: Add Timestamp to catalog-info.yaml
    action: catalog:timestamping

steps:
  - id: append-templateRef
    name: Append the entityRef of this template to the entityRef
    action: catalog:scaffolded-from

steps:
  - id: add-fields-to-catalog-info
    name: Add a few fields into `catalog-info.yaml` using the generic action
    action: catalog:annotate
    input:
      labels:
        custom: ${{ parameters.label }}
        other: "test-label"
      annotations:
        custom.io/annotation: ${{ parameters.label }}
        custom.io/other: "value"

steps:
  - id: sendNotification
    action: notification:send
    name: Send Notification
    input:
      recipients: broadcast
      title: Test notification

 steps:
    - id: git
      name: git
      action: git
      input:
        command: ${{ parameters.command }} # ex: 'commit' - will make the scaffolder run the `git commit` command
        workingDirectory: ${{ parameters.workingDirectory }} # ex: './my-working-directory' - will execute the command in the specified directory relative to the scaffolder workspace
        args: ${{ parameters.args }} # ex: ['-m', 'My commit message'] - will add '-m My commit message' to the arguments passed to the git command

steps:
    - id: create-kubernetes-namespace
      name: Create kubernetes namespace
      action: kubernetes:create-namespace
      input:
        namespace: ${{ parameters.namespace }}
        clusterRef: ${{ parameters.clusterRef }}
        url: ${{ parameters.url }}
        token: ${{ parameters.token }}
        skipTLSVerify: ${{ parameters.skipTLSVerify }}
        caData: ${{ parameters.caData }}
        labels: ${{ parameters.labels }}

steps:
    - action: kube:apply
      id: k-apply
      name: Create a Resouce
      input:
        namespaced: true
        manifest: |
          apiVersion: example.group.bar/v1
          kind: Foo
          metadata:
            name: ${{ parameters.name }}
            namespace: default

steps:
    - action: kube:delete
      id: k-delete
      name: Delete
      input:
        apiVersion: example.group.bar/v1
        kind: Foo
        namespace: ${{parameters.namespace}}
        name: ${{ parameters.name }}

steps:
  - action: kube:job:wait
    id: k-wait
    name: Wait for a Job to complete
    input:
      labels:
        job-name: foo-bar
        # more labels

steps:
  - id: maven
    name: maven
    action: maven
    input:
      command: ${{ parameters.command }} # ex: 'clean package' 
      workingDirectory: ${{ parameters.workingDirectory }} # ex: './my-working-directory' - will execute the command in the specified directory relative to the scaffolder workspace
      args: ${{ parameters.args }} # ex: ['-P', 'Profile'] - will add '-P Profile' to the arguments passed to the maven command