Feature Request: Support dsc functions in executable args

[EmperorArthur]

Summary of the new feature / enhancement

It would be extremely convenient to support functions in the argument list for DSC resources.

Currently the only three ways to pass custom parameters to a process are:

• environment variables
• stdin
• An input argument of { "jsonInputArg": "-json"} or similar.

I would like to propose a 4th option. Strings generated by dsc functions.

This would massively decrease the need for custom programs whose only purpose is to deal with JSON.

Proposed technical implementation details (optional)

• Support parser.parse_and_execute for each string within an "args" array.
• Add a jsonInputArg() function to obtain the object representing jsonInputArg.

For example, a custom resource to set a system wide git config variable would look like:

"schema": {
  "embedded": {
    "properties": {
       "key": {
          "type": "string"
        },
        "value": {
          "type": "string"
        }
    },
    "required": [
        "key",
        "value"
      ],
      "title": "git_config",
      "type": "object"
  }
}
"set": {
    "executable": "git",
    "args": [
      "config",
      "set",
      "--system",
      "[tryget(jsonInputArg(),'key')]",
      "[tryget(jsonInputArg(),'value')]"
    ]
  }

[SteveL-MSFT]

WG discussed this, current proposal looks like:

{
  "set": {
    "executable": "git",
    "args": [
      "config",
      "set",
      "--system",
      {
         "expression": "[jsonInput().key]"
      },
      {
         "expression": "[jsonInput().value)]"
      }
    ]
 }

[EmperorArthur]

Awesome! One edge case that needs to be considered is if the expression evaluates to an empty string or null.

I don't think any program expects an argv value to be an empty string. Especially followed by non null values.

Example for what my personal pip implementation would look like. The first three expression invocations are deliberately contrived, but the 4th is an example of an optional argument.

"set": {
    "executable": "python",
    "args": [
      "-m",
      {
        "expression": "[null()]"
      },
      {
        "expression": "['']"
      },
      {
        "expression": "[]"
      },
      {
        "expression": "[if(jsonInput().useLatest, '--upgrade', '')]"
      },
      "pip",
      "--no-input",
      "--disable-pip-version-check",
      {
        "expression": "[if(jsonInput().useLatest, '--upgrade', null())]"
      },
      {
        "expression": "[concat(jsonInput().name, if(equals(jsonInput().version, null()), '', concat('==', jsonInput().version))]"
      }
    ]
  }

With a resource schema of:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "_exist": {
      "description": "Indicates whether an instance should or does exist",
      "type": "boolean"
    },
    "name": {
      "type": "string"
    },
    "version": {
      "type": "string"
    },
    "useLatest": {
      "default": false,
      "description": "Indicate that the latest available version of the package should be installed",
      "type": "boolean"
    }
  },
  "required": [
    "name"
  ],
  "oneOf": [
    {
      "not": {
        "required": [
          "version"
        ]
      },
      "properties": {
        "_exist": {
          "const": false
        },
        "useLatest": {
          "const": false
        }
      }
    },
    {
      "properties": {
        "_exist": {
          "const": true
        },
        "useLatest": {
          "const": false
        }
      }
    },
    {
      "not": {
        "required": [
          "version"
        ]
      },
      "properties": {
        "_exist": {
          "const": true
        },
        "useLatest": {
          "const": true
        }
      }
    }
  ],
  "title": "pip_package",
  "type": "object"
}

[SteveL-MSFT]

We can borrow from the jsonInputArg with a mandatory property which defaults to false. If mandatory is false and the expression evaluates to null or an empty string, then that arg is not passed. If mandatory is true then whether it's empty or null, it's passed as an empty string. For this to work, this means the syntax would be changed to:

{
  "arg": "-m",
  "expression": "[null()]",
  "mandatory": true
}

Here, it would pass -m "". Whereas:

{
  "arg": "-m",
  "expression": "[null()]",
  "mandatory": false
}

would skip passing -m at all. I suppose if we want to support positional args and not just named ones, we would simply allow arg to not be specified:

{
  "expression": "[null()]",
  "mandatory": true
}

this is would pass an empty "" as an explicit positional argument

A new jsonInput() function would be added that simply returns to the expression the JSON input as a JSON object so you can use dot notation to access members:

{
  "expression": "[jsonInput().key]"
}

In this case, if key is a property that is a string or number, it will be passed as argument value. true and false would be true and false as strings. If it results in a JSON array or object, then that JSON string will be passed as the value. If the property doesn't exist, it's a normal expression error and that resource won't be called.

[SteveL-MSFT]

The WG discussed this and accepts my proposal above