@pipedream/google_calendar 0.5.2 → 0.5.3

package/actions/list-events-by-type/list-events-by-type.mjs

@@ -1,56 +0,0 @@
-import googleCalendar from "../../google_calendar.app.mjs";
-import utils from "../../common/utils.mjs";
-
-export default {
-  key: "google_calendar-list-events-by-type",
-  name: "List Calendar Events by Type",
-  description: "Retrieve a list of events filtered by type (\"default\", \"focusTime\", \"outOfOffice\", \"workingLocation\") from the Google Calendar. [See the documentation](https://developers.google.com/calendar/api/v3/reference/events/list)",
-  version: "0.0.1",
-  type: "action",
-  props: {
-    googleCalendar,
-    calendarId: {
-      propDefinition: [
-        googleCalendar,
-        "calendarId",
-      ],
-    },
-    eventTypes: {
-      propDefinition: [
-        googleCalendar,
-        "eventTypes",
-      ],
-    },
-    maxResults: {
-      propDefinition: [
-        googleCalendar,
-        "maxResults",
-      ],
-    },
-  },
-  async run({ $ }) {
-    const args = utils.filterEmptyValues({
-      calendarId: this.calendarId,
-      eventTypes: this.eventTypes,
-    });
-    const events = [];
-    let total, done = false, count = 0;
-    do {
-      const response = await this.googleCalendar.listEvents(args);
-      for (const item of response.items) {
-        events.push(item);
-        count++;
-        if (this.maxResults && count >= this.maxResults) {
-          done = true;
-          break;
-        }
-      }
-      total = response.items?.length;
-      args.syncToken = response.nextSyncToken;
-    } while (total && !done);
-
-    $.export("$summary", `Successfully retrieved ${events.length} event(s)`);
-
-    return events;
-  },
-};

package/sources/event-start/event-start.mjs

@@ -1,60 +0,0 @@
-import common from "../common/common.mjs";
-import sampleEmit from "./test-event.mjs";
-
-export default {
-  ...common,
-  key: "google_calendar-event-start",
-  name: "New Event Start",
-  description: "Emit new event when the specified time before the Google Calendar event starts",
-  version: "0.1.8",
-  type: "source",
-  dedupe: "unique",
-  props: {
-    ...common.props,
-    calendarId: {
-      propDefinition: [
-        common.props.googleCalendar,
-        "calendarId",
-      ],
-    },
-    minutesBefore: {
-      type: "integer",
-      label: "Minutes Before",
-      description: "Emit the event this many minutes before the event starts",
-      default: 5,
-    },
-  },
-  methods: {
-    ...common.methods,
-    getMillisecondsBefore() {
-      return +this.minutesBefore * 60 * 1000;
-    },
-    getConfig({
-      now, intervalMs,
-    }) {
-      const {
-        getMillisecondsBefore,
-        calendarId,
-      } = this;
-
-      const timeMin = new Date(now.getTime() - getMillisecondsBefore()).toISOString();
-      const timeMax = new Date(now.getTime() + intervalMs).toISOString();
-      return {
-        calendarId,
-        timeMax,
-        timeMin,
-        singleEvents: true,
-        orderBy: "startTime",
-      };
-    },
-    isRelevant(event, {
-      now, intervalMs,
-    }) {
-      const start = new Date(event?.start?.dateTime);
-      const msFromStart = start.getTime() - now.getTime();
-      return msFromStart > 0
-        && msFromStart < (this.getMillisecondsBefore() + intervalMs);
-    },
-  },
-  sampleEmit,
-};

package/sources/event-start/test-event.mjs

@@ -1,32 +0,0 @@
-export default  {
-  "kind": "calendar#meeting",
-  "etag": "\"3299999999966000\"",
-  "id": "3459g2tr92dbuwecv8m939jplk",
-  "status": "upcoming",
-  "htmlLink": "https://www.google.com/calendar/event?eid=MzQ1OWcydHI5MmRidXlldm45bTg5MzlwamsgeHhudkBzYW5kYm94LmNvbQ",
-  "created": "2025-09-13T08:25:45.000Z",
-  "updated": "2025-09-13T08:25:45.983Z",
-  "summary": "Sample Event 2005",
-  "creator": {
-   "email": "xhx.v@sandbox.com",
-   "self": true
-  },
-  "organizer": {
-   "email": "xhx.v@sandbox.com",
-   "self": true
-  },
-  "start": {
-   "dateTime": "2025-09-13T18:30:00+09:00",
-   "timeZone": "Asia/Tokyo"
-  },
-  "end": {
-   "dateTime": "2025-09-13T19:00:00+09:00",
-   "timeZone": "Asia/Tokyo"
-  },
-  "iCalUID": "3459g2tr92dbuwecv8m939jplk@google.com",
-  "sequence": 1,
-  "reminders": {
-   "useDefault": true
-  },
-  "eventType": "normal"
- }

package/sources/new-event/new-event.mjs

@@ -1,36 +0,0 @@
-import common from "../common/common.mjs";
-
-export default {
-  ...common,
-  key: "google_calendar-new-event",
-  name: "New Event Created",
-  description: "Emit new event when a Google Calendar event is created",
-  version: "0.1.7",
-  type: "source",
-  dedupe: "unique",
-  props: {
-    ...common.props,
-    calendarId: {
-      propDefinition: [
-        common.props.googleCalendar,
-        "calendarId",
-      ],
-    },
-  },
-  methods: {
-    ...common.methods,
-    getConfig({ past }) {
-      const updatedMin = past.toISOString();
-      return {
-        calendarId: this.calendarId,
-        updatedMin,
-        singleEvents: true,
-        orderBy: "startTime",
-      };
-    },
-    isRelevant(event, { past }) {
-      const created = new Date(event.created);
-      return created > past && event.status !== "cancelled";
-    },
-  },
-};

package/sources/new-or-updated-event/new-or-updated-event.mjs

@@ -1,48 +0,0 @@
-import common from "../common/common.mjs";
-
-export default {
-  ...common,
-  key: "google_calendar-new-or-updated-event",
-  name: "New Created or Updated Event",
-  description: "Emit new event when a Google Calendar events is created or updated (does not emit cancelled events)",
-  version: "0.1.7",
-  type: "source",
-  dedupe: "unique",
-  props: {
-    ...common.props,
-    calendarId: {
-      propDefinition: [
-        common.props.googleCalendar,
-        "calendarId",
-      ],
-    },
-  },
-  methods: {
-    ...common.methods,
-    getConfig({ past }) {
-      const updatedMin = past.toISOString();
-      return {
-        calendarId: this.calendarId,
-        updatedMin,
-        singleEvents: true,
-        orderBy: "startTime",
-      };
-    },
-    isRelevant(event) {
-      return event.status !== "cancelled";
-    },
-    generateMeta(event) {
-      const {
-        id,
-        summary,
-        updated: tsString,
-      } = event;
-      const ts = Date.parse(tsString);
-      return {
-        id: `${id}-${ts}`,
-        summary,
-        ts,
-      };
-    },
-  },
-};

package/sources/upcoming-event-type-alert/upcoming-event-type-alert.mjs

@@ -1,149 +0,0 @@
-import taskScheduler from "../../../pipedream/sources/new-scheduled-tasks/new-scheduled-tasks.mjs";
-import googleCalendar from "../../google_calendar.app.mjs";
-
-export default {
-  key: "google_calendar-upcoming-event-type-alert",
-  name: "New Upcoming Event Type Alert",
-  description: `Emit new event based on a time interval before an upcoming event of the specified type ("default", "focusTime", "outOfOffice", "workingLocation") in the calendar. This source uses Pipedream's Task Scheduler.
-    [See the documentation](https://pipedream.com/docs/examples/waiting-to-execute-next-step-of-workflow/#step-1-create-a-task-scheduler-event-source) 
-    for more information and instructions for connecting your Pipedream account.`,
-  version: "0.0.1",
-  type: "source",
-  props: {
-    pipedream: taskScheduler.props.pipedream,
-    googleCalendar,
-    db: "$.service.db",
-    http: "$.interface.http",
-    calendarId: {
-      propDefinition: [
-        googleCalendar,
-        "calendarId",
-      ],
-    },
-    eventTypes: {
-      propDefinition: [
-        googleCalendar,
-        "eventTypes",
-      ],
-    },
-    time: {
-      type: "integer",
-      label: "Minutes Before",
-      description: "Number of minutes to trigger before the start of the calendar event.",
-      min: 0,
-      reloadProps: true,
-    },
-  },
-  async additionalProps() {
-    const props = {};
-    if (this.time > 0) {
-      props.timer = {
-        type: "$.interface.timer",
-        description: "Poll the API to schedule alerts for any newly created events",
-        default: {
-          intervalSeconds: 60 * this.time,
-        },
-      };
-    }
-    return props;
-  },
-  hooks: {
-    async deactivate() {
-      const ids = this._getScheduledEventIds();
-      if (!ids?.length) {
-        return;
-      }
-      for (const id of ids) {
-        if (await this.deleteEvent({
-          body: {
-            id,
-          },
-        })) {
-          console.log("Cancelled scheduled event");
-        }
-      }
-      this._setScheduledEventIds();
-    },
-  },
-  methods: {
-    ...taskScheduler.methods,
-    _getScheduledEventIds() {
-      return this.db.get("scheduledEventIds");
-    },
-    _setScheduledEventIds(ids) {
-      this.db.set("scheduledEventIds", ids);
-    },
-    _getScheduledCalendarEventIds() {
-      return this.db.get("scheduledCalendarEventIds");
-    },
-    _setScheduledCalendarEventIds(ids) {
-      this.db.set("scheduledCalendarEventIds", ids);
-    },
-    _hasDeployed() {
-      const result = this.db.get("hasDeployed");
-      this.db.set("hasDeployed", true);
-      return result;
-    },
-    subtractMinutes(date, minutes) {
-      return date.getTime() - minutes * 60000;
-    },
-    async getCalendarEvents() {
-      const calendarEvents = [];
-      const params = {
-        calendarId: this.calendarId,
-        eventTypes: this.eventTypes,
-      };
-      do {
-        const {
-          data: {
-            items, nextPageToken,
-          },
-        } = await this.googleCalendar.getEvents(params);
-        if (items?.length) {
-          calendarEvents.push(...items);
-        }
-        params.pageToken = nextPageToken;
-      } while (params.pageToken);
-      return calendarEvents;
-    },
-  },
-  async run(event) {
-    // self subscribe only on the first time
-    if (!this._hasDeployed()) {
-      await this.selfSubscribe();
-    }
-
-    const scheduledEventIds = this._getScheduledEventIds() || [];
-
-    // incoming scheduled event
-    if (event.$channel === this.selfChannel()) {
-      const remainingScheduledEventIds = scheduledEventIds.filter((id) => id !== event["$id"]);
-      this._setScheduledEventIds(remainingScheduledEventIds);
-      this.emitEvent(event, `Upcoming ${event.summary} event`);
-      return;
-    }
-
-    // schedule new events
-    const scheduledCalendarEventIds = this._getScheduledCalendarEventIds() || {};
-    const calendarEvents = await this.getCalendarEvents();
-
-    for (const calendarEvent of calendarEvents) {
-      const startTime = calendarEvent.start
-        ? (new Date(calendarEvent.start.dateTime || calendarEvent.start.date))
-        : null;
-      if (!startTime
-        || startTime.getTime() < Date.now()
-        || scheduledCalendarEventIds[calendarEvent.id])
-      {
-        continue;
-      }
-      const later = new Date(this.subtractMinutes(startTime, this.time));
-
-      const scheduledEventId = this.emitScheduleEvent(calendarEvent, later);
-      scheduledEventIds.push(scheduledEventId);
-      scheduledCalendarEventIds[calendarEvent.id] = true;
-    }
-    this._setScheduledEventIds(scheduledEventIds);
-    this._setScheduledCalendarEventIds(scheduledCalendarEventIds);
-  },
-};