@pipedream/redmine 0.0.1 → 0.1.0

package/actions/create-issue/create-issue.mjs

@@ -0,0 +1,69 @@
+import app from "../../redmine.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  key: "redmine-create-issue",
+  name: "Create Issue",
+  description: "Creates a new issue in Redmine. [See the documentation](https://www.redmine.org/projects/redmine/wiki/rest_issues#creating-an-issue)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    projectId: {
+      propDefinition: [
+        app,
+        "projectId",
+      ],
+    },
+    trackerId: {
+      propDefinition: [
+        app,
+        "trackerId",
+      ],
+    },
+    subject: {
+      type: "string",
+      label: "Subject",
+      description: "The subject of the issue",
+    },
+    description: {
+      type: "string",
+      label: "Description",
+      description: "The description of the issue",
+    },
+    statusId: {
+      propDefinition: [
+        app,
+        "statusId",
+      ],
+    },
+    priorityId: {
+      propDefinition: [
+        app,
+        "priorityId",
+      ],
+    },
+  },
+  methods: {
+    createIssue(args = {}) {
+      return this.app.post({
+        path: "/issues.json",
+        ...args,
+      });
+    },
+  },
+  run({ $: step }) {
+    const {
+      createIssue,
+      ...issue
+    } = this;
+
+    return createIssue({
+      step,
+      data: {
+        issue: utils.transformProps(issue),
+      },
+      summary: (response) => `Successfully created issue with ID: \`${response.issue?.id}\``,
+    });
+  },
+};

package/actions/delete-user/delete-user.mjs

@@ -0,0 +1,40 @@
+import app from "../../redmine.app.mjs";
+
+export default {
+  key: "redmine-delete-user",
+  name: "Delete User",
+  description: "Deletes a user from the Redmine platform. [See the documentation](https://www.redmine.org/projects/redmine/wiki/rest_users#delete)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    userId: {
+      propDefinition: [
+        app,
+        "userId",
+      ],
+    },
+  },
+  methods: {
+    deleteUser({
+      userId, ...args
+    } = {}) {
+      return this.app.delete({
+        path: `/users/${userId}.json`,
+        ...args,
+      });
+    },
+  },
+  run({ $: step }) {
+    const {
+      deleteUser,
+      userId,
+    } = this;
+
+    return deleteUser({
+      step,
+      userId,
+      summary: () => "Successfully deleted user",
+    });
+  },
+};

package/actions/update-project/update-project.mjs

@@ -0,0 +1,75 @@
+import app from "../../redmine.app.mjs";
+import utils from "../../common/utils.mjs";
+
+export default {
+  key: "redmine-update-project",
+  name: "Update Project",
+  description: "Updates an existing project in Redmine. [See the documentation](https://www.redmine.org/projects/redmine/wiki/rest_projects#updating-a-project)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    projectId: {
+      propDefinition: [
+        app,
+        "projectId",
+      ],
+    },
+    name: {
+      type: "string",
+      label: "Name",
+      description: "The name of the project",
+      optional: true,
+    },
+    description: {
+      type: "string",
+      label: "Description",
+      description: "The description of the project",
+      optional: true,
+    },
+    homepage: {
+      type: "string",
+      label: "Homepage",
+      description: "The homepage of the project",
+      optional: true,
+    },
+    isPublic: {
+      type: "boolean",
+      label: "Is Public",
+      description: "Whether the project is public",
+      optional: true,
+    },
+    inheritMembers: {
+      type: "boolean",
+      label: "Inherit Members",
+      description: "Whether the project should inherit members from its parent",
+      optional: true,
+    },
+  },
+  methods: {
+    updateProject({
+      projectId, ...args
+    } = {}) {
+      return this.app.put({
+        path: `/projects/${projectId}.json`,
+        ...args,
+      });
+    },
+  },
+  run({ $: step }) {
+    const {
+      updateProject,
+      projectId,
+      ...project
+    } = this;
+
+    return updateProject({
+      step,
+      projectId,
+      data: {
+        project: utils.transformProps(project),
+      },
+      summary: () => "Successfully updated project",
+    });
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,15 @@
+const SUMMARY_LABEL = "$summary";
+const DOMAIN_PLACEHOLDER = "{domain}";
+const BASE_URL = `https://${DOMAIN_PLACEHOLDER}`;
+const LAST_CREATED_AT = "lastCreatedAt";
+const DEFAULT_MAX = 600;
+const DEFAULT_LIMIT = 60;
+
+export default {
+  SUMMARY_LABEL,
+  DOMAIN_PLACEHOLDER,
+  BASE_URL,
+  DEFAULT_MAX,
+  DEFAULT_LIMIT,
+  LAST_CREATED_AT,
+};

package/common/utils.mjs

@@ -0,0 +1,43 @@
+function toSnakeCase(str) {
+  return str?.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+
+function keysToSnakeCase(data = {}) {
+  return Object.entries(data)
+    .reduce((acc, [
+      key,
+      value,
+    ]) => ({
+      ...acc,
+      [toSnakeCase(key)]: value,
+    }), {});
+}
+
+function transformProps(props) {
+  if (!props) {
+    return;
+  }
+
+  return keysToSnakeCase(
+    Object.fromEntries(
+      Object.entries(props)
+        .filter(([
+          key,
+          value,
+        ]) => typeof(value) !== "function" && key !== "app"),
+    ),
+  );
+}
+
+async function iterate(iterations) {
+  const items = [];
+  for await (const item of iterations) {
+    items.push(item);
+  }
+  return items;
+}
+
+export default {
+  transformProps,
+  iterate,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/redmine",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream Redmine Components",
   "main": "redmine.app.mjs",
   "keywords": [

package/redmine.app.mjs

@@ -1,11 +1,226 @@
+import {
+  axios, ConfigurationError,
+} from "@pipedream/platform";
+import constants from "./common/constants.mjs";
+import utils from "./common/utils.mjs";
+
 export default {
   type: "app",
   app: "redmine",
-  propDefinitions: {},
+  propDefinitions: {
+    projectId: {
+      type: "integer",
+      label: "Project ID",
+      description: "The ID of the project",
+      async options() {
+        const response = await this.listProjects();
+        console.log(response);
+        const { projects } = response;
+        return projects.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    trackerId: {
+      type: "integer",
+      label: "Tracker ID",
+      description: "The ID of the tracker",
+      async options() {
+        const { trackers } = await this.listTrackers();
+        return trackers.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    statusId: {
+      type: "integer",
+      label: "Status ID",
+      description: "The ID of the status",
+      async options() {
+        const { issue_statuses: statuses } = await this.listIssueStatuses();
+        return statuses.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    priorityId: {
+      type: "integer",
+      label: "Priority ID",
+      description: "The ID of the priority",
+      async options() {
+        const { issue_priorities: priorities } = await this.listIssuePriorities();
+        return priorities.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    userId: {
+      type: "integer",
+      label: "User ID",
+      description: "The ID of the user",
+      async options() {
+        const { users } = await this.listUsers();
+        return users.map(({
+          id: value, login: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    exportSummary(step) {
+      if (!step?.export) {
+        throw new ConfigurationError("The summary method should be bind to the step object aka `$`");
+      }
+      return (msg = "") => step.export(constants.SUMMARY_LABEL, msg);
+    },
+    getUrl(path) {
+      const baseUrl = constants.BASE_URL
+        .replace(constants.DOMAIN_PLACEHOLDER, this.$auth.hostname);
+      return `${baseUrl}${path}`;
+    },
+    async makeRequest({
+      step = this, path, headers, summary, ...args
+    } = {}) {
+      const {
+        getUrl,
+        exportSummary,
+        $auth: { api_key: apiKey },
+      } = this;
+
+      const config = {
+        ...args,
+        url: getUrl(path),
+        headers: {
+          ...headers,
+          "X-Redmine-API-Key": apiKey,
+        },
+      };
+
+      const response = await axios(step, config);
+
+      if (typeof(summary) === "function") {
+        exportSummary(step)(summary(response));
+      }
+
+      return response || {
+        success: true,
+      };
+    },
+    post(args = {}) {
+      return this.makeRequest({
+        method: "post",
+        ...args,
+      });
+    },
+    put(args = {}) {
+      return this.makeRequest({
+        method: "put",
+        ...args,
+      });
+    },
+    delete(args = {}) {
+      return this.makeRequest({
+        method: "delete",
+        ...args,
+      });
+    },
+    listIssues(args = {}) {
+      return this.makeRequest({
+        path: "/issues.json",
+        ...args,
+      });
+    },
+    listProjects(args = {}) {
+      return this.makeRequest({
+        path: "/projects.json",
+        ...args,
+      });
+    },
+    listTrackers(args = {}) {
+      return this.makeRequest({
+        path: "/trackers.json",
+        ...args,
+      });
+    },
+    listIssueStatuses(args = {}) {
+      return this.makeRequest({
+        path: "/issue_statuses.json",
+        ...args,
+      });
+    },
+    listIssuePriorities(args = {}) {
+      return this.makeRequest({
+        path: "/enumerations/issue_priorities.json",
+        ...args,
+      });
+    },
+    listUsers(args = {}) {
+      return this.makeRequest({
+        path: "/users.json",
+        ...args,
+      });
+    },
+    async *getIterations({
+      resourceFn,
+      resourceFnArgs,
+      resourceName,
+      max = constants.DEFAULT_MAX,
+    }) {
+      let offset = 0;
+      let resourcesCount = 0;
+
+      while (true) {
+        const response =
+          await resourceFn({
+            ...resourceFnArgs,
+            params: {
+              offset,
+              limit: constants.DEFAULT_LIMIT,
+              ...resourceFnArgs?.params,
+            },
+          });
+
+        const nextResources = resourceName && response[resourceName] || response;
+
+        if (!nextResources?.length) {
+          console.log("No more resources found");
+          return;
+        }
+
+        for (const resource of nextResources) {
+          yield resource;
+          resourcesCount += 1;
+
+          if (resourcesCount >= max) {
+            return;
+          }
+        }
+
+        if (nextResources.length < constants.DEFAULT_LIMIT) {
+          console.log("Less resources than the limit found, no more resources to fetch");
+          return;
+        }
+
+        offset += constants.DEFAULT_LIMIT;
+      }
+    },
+    paginate(args = {}) {
+      return utils.iterate(this.getIterations(args));
     },
   },
-};
+};

package/sources/common/base.mjs

@@ -0,0 +1,14 @@
+import { ConfigurationError } from "@pipedream/platform";
+import app from "../../redmine.app.mjs";
+
+export default {
+  props: {
+    app,
+    db: "$.service.db",
+  },
+  methods: {
+    generateMeta() {
+      throw new ConfigurationError("generateMeta is not implemented");
+    },
+  },
+};

package/sources/common/polling.mjs

@@ -0,0 +1,58 @@
+import {
+  ConfigurationError,
+  DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+} from "@pipedream/platform";
+import common from "./base.mjs";
+
+export default {
+  ...common,
+  props: {
+    ...common.props,
+    timer: {
+      type: "$.interface.timer",
+      label: "Polling schedule",
+      description: "How often to poll the API",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+  },
+  methods: {
+    ...common.methods,
+    getResourceName() {
+      throw new ConfigurationError("getResourceName is not implemented");
+    },
+    getResourceFn() {
+      throw new ConfigurationError("getResourceFn is not implemented");
+    },
+    getResourceFnArgs() {
+      throw new ConfigurationError("getResourceFnArgs is not implemented");
+    },
+    processEvent(resource) {
+      const meta = this.generateMeta(resource);
+      this.$emit(resource, meta);
+    },
+    async processResources(resources) {
+      Array.from(resources)
+        .reverse()
+        .forEach(this.processEvent);
+    },
+  },
+  async run() {
+    const {
+      app,
+      getResourceFn,
+      getResourceFnArgs,
+      getResourceName,
+      processResources,
+    } = this;
+
+    const resources = await app.paginate({
+      resourceFn: getResourceFn(),
+      resourceFnArgs: getResourceFnArgs(),
+      resourceName: getResourceName(),
+    });
+
+    processResources(resources);
+  },
+};

package/sources/issue-created/issue-created.mjs

@@ -0,0 +1,34 @@
+import common from "../common/polling.mjs";
+
+export default {
+  ...common,
+  key: "redmine-issue-created",
+  name: "New Issue Created",
+  description: "Emit new event when a new issue is created in Redmine",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getResourceName() {
+      return "issues";
+    },
+    getResourceFn() {
+      return this.app.listIssues;
+    },
+    getResourceFnArgs() {
+      return {
+        params: {
+          sort: "created_on:desc",
+        },
+      };
+    },
+    generateMeta(resource) {
+      return {
+        id: resource.id,
+        summary: `New Issue: ${resource.subject}`,
+        ts: Date.parse(resource.created_on),
+      };
+    },
+  },
+};

package/sources/project-updated/project-updated.mjs

@@ -0,0 +1,35 @@
+import common from "../common/polling.mjs";
+
+export default {
+  ...common,
+  key: "redmine-project-updated",
+  name: "Project Updated",
+  description: "Emits an event whenever a project is updated in Redmine",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getResourceName() {
+      return "projects";
+    },
+    getResourceFn() {
+      return this.app.listProjects;
+    },
+    getResourceFnArgs() {
+      return {
+        params: {
+          sort: "updated_on:desc",
+        },
+      };
+    },
+    generateMeta(resource) {
+      const ts = Date.parse(resource.updated_on);
+      return {
+        id: `${resource.id}-${ts}`,
+        summary: `Project Updated: ${resource.name}`,
+        ts,
+      };
+    },
+  },
+};