Component API Reference

export default {
  name: "",
  key: "",
  type: "",
  version: "",
  description: "",
  props: {},
  methods: {},
  hooks: {
    async activate() {},
    async deactivate() {},
    async deploy() {},
  },
  dedupe: "",
  async run(event) {
    this.$emit(event);
  },
};

props: {
  myPropName: {
    type: "",
    label: "",
    description: "",
    options: [], // OR async options() {} to return dynamic options
    optional: true || false,
    propDefinition: [],
    default: "",
    secret: true || false,
    format: "",
    min: <integer>,
    max: <integer>,
    disabled: true || false,
    hidden: true || false
  },
},

export default {
  name: "User Input Prop Example",
  version: "0.1",
  props: {
    msg: {
      type: "string",
      label: "Message",
      description: "Enter a message to `console.log()`",
    },
  },
  async run() {
    this.$emit(this.msg);
  },
};

async options({
  page,
  prevContext,
  query,
}) {},

export default {
  name: "Async Options Example",
  version: "0.1",
  props: {
    msg: {
      type: "string",
      label: "Message",
      description: "Select a message to `console.log()`",
      async options() {
        // write any node code that returns a string[] or object[] (with label/value keys)
        return ["This is option 1", "This is option 2"];
      },
    },
  },
  async run() {
    this.$emit(this.msg);
  },
};

props: {
  myPropName: {
    propDefinition: [
      app,
      "propDefinitionName",
      inputValues
    ]
  },
},
 

const rss = {
  type: "app",
  app: "rss",
  propDefinitions: {
    urlDef: {
      type: "string",
      label: "RSS URL",
      description: "Enter a URL for an RSS feed.",
    },
  },
};
 
export default {
  name: "Prop Definition Example",
  description: `This component captures an RSS URL and logs it`,
  version: "0.1",
  props: {
    rss,
    url: { propDefinition: [rss, "urlDef"] },
  },
  async run() {
    console.log(this.url);
  },
};

board: {
  type: "string",
  label: "Board",
  async options(opts) {
    const boards = await this.getBoards(this.$auth.oauth_uid);
    const activeBoards = boards.filter((board) => board.closed === false);
    return activeBoards.map((board) => {
      return { label: board.name, value: board.id };
    });
  },
},
lists: {
  type: "string[]",
  label: "Lists",
  optional: true,
  async options(opts) {
    const lists = await this.getLists(opts.board);
    return lists.map((list) => {
      return { label: list.name, value: list.id };
    });
  },
}

board: { propDefinition: [trello, "board"] },
lists: {
  propDefinition: [
    trello,
    "lists",
    (configuredProps) => ({ board: configuredProps.board }),
  ],
},

hasHeaders: {
  type: "string",
  label: "Does the first row of the sheet have headers?",
  description: "If the first row of your document has headers we'll retrieve them to make it easy to enter the value for each column.",
  options: [
    "Yes",
    "No",
  ],
  reloadProps: true,
},

async additionalProps() {
  const sheetId = this.sheetId?.value || this.sheetId;
  const props = {};
  if (this.hasHeaders === "Yes") {
    const { values } = await this.googleSheets.getSpreadsheetValues(sheetId, `${this.sheetName}!1:1`);
    if (!values[0]?.length) {
      throw new ConfigurationError("Cound not find a header row. Please either add headers and click \"Refresh fields\" or adjust the action configuration to continue.");
    }
    for (let i = 0; i < values[0]?.length; i++) {
      props[`col_${i.toString().padStart(4, "0")}`] = {
        type: "string",
        label: values[0][i],
        optional: true,
      };
    }
  } else if (this.hasHeaders === "No") {
    props.myColumnData = {
      type: "string[]",
      label: "Values",
      description: "Provide a value for each cell of the row. Google Sheets accepts strings, numbers and boolean values for each cell. To set a cell to an empty value, pass an empty string.",
    };
  }
  return props;
},

async additionalProps(previousPropDefs)

async additionalProps(previousPropDefs) {
  if (this.myCondition === "Yes") {
    previousPropDefs.myPropName.disabled = true;
    previousPropDefs.myPropName.hidden = true;
  } else {
    previousPropDefs.myPropName.disabled = false;
    previousPropDefs.myPropName.hidden = false;
  }
  return previousPropDefs;
},

props: {
  myPropName: {
    type: "$.interface.timer",
    default: {},
  },
}

export default {
  name: "Cron Example",
  version: "0.1",
  props: {
    timer: {
      type: "$.interface.timer",
      default: {
        cron: "0 0 * * *", // Run job once a day
      },
    },
  },
  async run() {
    console.log("hello world!");
  },
};

export default {
  name: "Interval Example",
  version: "0.1",
  props: {
    timer: {
      type: "$.interface.timer",
      default: {
        intervalSeconds: 60 * 60 * 24, // Run job once a day
      },
    },
  },
  async run() {
    console.log("hello world!");
  },
};

props: {
  myPropName: {
    type: "$.interface.http",
    customResponse: true, // optional: defaults to false
  },
}

{
  method: 'POST',
  path: '/',
  query: {},
  headers: {},
  bodyRaw: '',
  body:
}

export default {
  name: "HTTP Example",
  version: "0.0.1",
  props: {
    http: {
      type: "$.interface.http",
      customResponse: true,
    },
  },
  async run(event) {
    this.http.respond({
      status: 200,
      body: {
        msg: "hello world!",
      },
      headers: {
        "content-type": "application/json",
      },
    });
    console.log(event);
  },
};

props: {
  myPropName: "$.service.db",
}

props: {
  myPropName: {
    type: "app",
    app: "",
    propDefinitions: {}
    methods: {},
  },
},

export default {
  name: "HTTP Request Example",
  version: "0.0.1",
  props: {
    httpRequest: {
      type: "http_request",
      label: "API Request",
      default: {
        method: "GET",
        url: "https://jsonplaceholder.typicode.com/posts",
      }
    },
  },
  async run() {
    const { data } = await this.httpRequest.execute();
    return data;
  },
};

export default defineComponent({
  props: {
    alert: {
      type: "alert",
      alertType: "info",
      content: "Admin rights on the repo are required in order to register webhooks. In order to continue setting up your source, configure a polling interval below to check for new events.",
    }
  },
})

methods: {
  random() {
    return Math.random()
  },
}

const randomNum = this.random();

hooks: {
  async deploy() {},
  async activate() {},
  async deactivate() {},
},

async run(event) {
  console.log(event)
}

this.$emit(event, {
  id,
  name,
  summary,
  ts,
});

export default {
  name: "this.$emit() example",
  description: "Deploy and run this component manually via the Pipedream UI",
  async run() {
    this.$emit({ message: "hello world!" });
  },
};

pd logs <deployed-component-name>

pd events <deployed-component-name>

async run({ $ }) {
  // You have access to $ within your action
}

async run({ $ }) {
  return "data"
}

async run({ $ }) {
  $.export("name", "value")
}

async run({ $ }) {
  $.respond({
    status: 200,
    body: "hello, world"
  })
}

async run({ $ }) {
  return $.flow.exit("reason")
}

const data = [1, 2];
const playlistName = "Cool jams";
$.export(
  "$summary",
  `Successfully added ${data.length} ${
    data.length == 1 ? "item" : "items"
  } to "${playlistName}"`
);

import axios from "axios";

pd dev <filename>

pd dev --dc <existing-deployed-component-id> <file-or-name>

pd deploy <filename>

pd deploy my-source.js

pd deploy <source-key>

pd deploy http-new-requests

pd deploy <url-to-raw-code>

pd deploy https://raw.githubusercontent.com/PipedreamHQ/pipedream/master/components/http/sources/new-requests/new-requests.js

https://pipedream.com/sources?action=create&key=<source-key>

https://pipedream.com/sources?action=create&key=http-new-requests

https://pipedream.com/sources?action=create&url=<url-encoded-url>

https://pipedream.com/sources?action=create&url=https%3A%2F%2Fraw.githubusercontent.com%2FPipedreamHQ%2Fpipedream%2Fmaster%2Fcomponents%2Fhttp%2Fhttp.js

pd publish FILENAME

pd publish my-action.js

pd events -n 10 <source-name>