caldav-adapter 4.3.1 → 5.0.1

package/index.js

@@ -0,0 +1,171 @@
+const path = require('node:path');
+const { pathToRegexp } = require('path-to-regexp');
+const basicAuth = require('basic-auth');
+const parseBody = require('./common/parse-body');
+const winston = require('./common/winston');
+const cal = require('./routes/calendar/calendar');
+const pri = require('./routes/principal/principal');
+
+const defaults = {
+  caldavRoot: '/',
+  calendarRoot: 'cal',
+  principalRoot: 'p',
+  logEnabled: false
+};
+
+module.exports = function (options) {
+  options = Object.assign(defaults, options);
+
+  const log = winston({ ...options, label: 'index' });
+
+  const rootRoute = path.join('/', options.caldavRoot);
+  const calendarRoute = path.join(rootRoute, options.calendarRoot);
+  const principalRoute = path.join(rootRoute, options.principalRoot, '/');
+
+  const rootRegexp = pathToRegexp(path.join(rootRoute, '/:params*'));
+  const calendarRegex = { keys: [] };
+  calendarRegex.regexp = pathToRegexp(
+    path.join(calendarRoute, '/:principalId/:calendarId?/:eventId*'),
+    calendarRegex.keys
+  );
+  const principalRegex = { keys: [] };
+  principalRegex.regexp = pathToRegexp(
+    path.join(principalRoute, '/:principalId?'),
+    principalRegex.keys
+  );
+
+  const calendarRoutes = cal({
+    logEnabled: options.logEnabled,
+    logLevel: options.logLevel,
+    data: options.data
+  });
+
+  const principalRoutes = pri({
+    logEnabled: options.logEnabled,
+    logLevel: options.logLevel,
+    data: options.data
+  });
+
+  const fillParameters = function (ctx) {
+    ctx.state.params = {};
+
+    let regex;
+    if (calendarRegex.regexp.test(ctx.url)) {
+      regex = calendarRegex;
+    } else if (principalRegex.regexp.test(ctx.url)) {
+      regex = principalRegex;
+    }
+
+    if (!regex) {
+      return;
+    }
+
+    const captures = ctx.url.match(regex.regexp);
+    for (let i = 0; i < regex.keys.length; i++) {
+      let captured = captures[i + 1];
+      if (typeof captured === 'string') {
+        captured = decodeURIComponent(captured);
+      }
+
+      ctx.state.params[regex.keys[i].name] = captured;
+      if (typeof captured === 'string' && captured.endsWith('.ics')) {
+        ctx.state.params[regex.keys[i].name] = captured.slice(0, -4);
+      }
+    }
+  };
+
+  const auth = async function (ctx) {
+    const creds = basicAuth(ctx);
+    if (!creds) {
+      ctx.status = 401;
+      ctx.response.set(
+        'WWW-Authenticate',
+        `Basic realm="${options.authRealm}"`
+      );
+      return false;
+    }
+
+    ctx.state.user = await options.authenticate({
+      username: creds.name,
+      password: creds.pass,
+      principalId: ctx.state.params.principalId
+    });
+    if (!ctx.state.user) {
+      ctx.status = 401;
+      ctx.response.set(
+        'WWW-Authenticate',
+        `Basic realm="${options.authRealm}"`
+      );
+      return false;
+    }
+
+    if (!ctx.state.params.principalId) {
+      ctx.state.params.principalId = ctx.state.user.principalId;
+    }
+
+    return true;
+  };
+
+  const fillRoutes = function (ctx) {
+    ctx.state.principalRootUrl = principalRoute;
+    if (ctx.state.params.principalId) {
+      ctx.state.calendarHomeUrl = path.join(
+        calendarRoute,
+        ctx.state.params.principalId,
+        '/'
+      );
+      ctx.state.principalUrl = path.join(
+        principalRoute,
+        ctx.state.params.principalId,
+        '/'
+      );
+      if (ctx.state.params.calendarId) {
+        ctx.state.calendarUrl = path.join(
+          calendarRoute,
+          ctx.state.params.principalId,
+          ctx.state.params.calendarId,
+          '/'
+        );
+      }
+    }
+  };
+
+  return async function (ctx, next) {
+    if (
+      ctx.url.toLowerCase() === '/.well-known/caldav' &&
+      !options.disableWellKnown
+    ) {
+      // Return ctx.redirect(rootRoute);
+      ctx.status = 404;
+      return;
+    }
+
+    if (!rootRegexp.test(ctx.url)) {
+      await next();
+      return;
+    }
+
+    ctx.state.caldav = true;
+    fillParameters(ctx);
+    const authed = await auth(ctx);
+    if (!authed) {
+      return;
+    }
+
+    fillRoutes(ctx);
+
+    await parseBody(ctx);
+    log.verbose('REQUEST BODY', ctx?.request?.body || '<empty>');
+
+    if (calendarRegex.regexp.test(ctx.url)) {
+      await calendarRoutes(ctx);
+    } else if (principalRegex.regexp.test(ctx.url)) {
+      await principalRoutes(ctx);
+    } else {
+      ctx.redirect(principalRoute);
+      return;
+    }
+
+    log.verbose('RESPONSE BODY', ctx.body || '<empty>');
+  };
+};

package/package.json

@@ -1,53 +1,71 @@
 {
   "name": "caldav-adapter",
-  "version": "4.3.1",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "description": "Middleware to handle CalDAV requests to node web server.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sedenardi/node-caldav-adapter.git"
-  },
-  "author": "Sanders DeNardi <sedenardi@gmail.com> (http://www.sandersdenardi.com/)",
-  "homepage": "https://github.com/sedenardi/node-caldav-adapter",
-  "license": "MIT",
-  "engines": {
-    "node": ">= 8.0.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "eslint": "eslint --ext .ts src/**",
-    "test": "npm run eslint && npm run build",
-    "watch": "nodemon -e js --ignore node_modules/ --inspect example/server.js"
-  },
-  "devDependencies": {
-    "@types/ical": "^0.6.1",
-    "@types/koa": "^2.13.12",
-    "@types/lodash": "^4.14.202",
-    "@types/node": "^20.10.6",
-    "@types/xmldom": "^0.1.34",
-    "@typescript-eslint/eslint-plugin": "^6.16.0",
-    "@typescript-eslint/parser": "^6.16.0",
-    "eslint": "^8.56.0",
-    "koa": "^2.15.0",
-    "koa-compress": "^5.1.1",
-    "koa-morgan": "^1.0.1",
-    "nodemon": "^3.0.2",
-    "typescript": "^5.3.3"
-  },
+  "description": "CalDAV server for Node.js and Koa. Modernized and maintained for Forward Email.",
+  "version": "5.0.1",
+  "author": "Sanders DeNardi and Forward Email LLC",
+  "contributors": [
+    "Sanders DeNardi <sedenardi@gmail.com> (http://www.sandersdenardi.com/)",
+    "Forward Email (https://forwardemail.net)"
+  ],
   "dependencies": {
+    "@xmldom/xmldom": "^0.8.10",
     "basic-auth": "^2.0.1",
-    "ical": "^0.8.0",
-    "ical-generator": "^1.10.0",
     "lodash": "^4.17.21",
     "moment": "^2.30.1",
-    "moment-timezone": "^0.5.44",
+    "node-ical": "^0.17.1",
     "path-to-regexp": "^6.2.1",
     "raw-body": "^2.5.2",
-    "rrule": "^2.8.1",
     "winston": "^3.11.0",
     "xmlbuilder2": "^3.1.1",
-    "xmldom": "^0.6.0",
     "xpath": "0.0.34"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^18.4.3",
+    "@commitlint/config-conventional": "^18.4.3",
+    "ava": "^5.3.1",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.55.0",
+    "eslint-config-xo-lass": "^2.0.1",
+    "fixpack": "^4.0.0",
+    "husky": "^8.0.3",
+    "koa": "^2.15.0",
+    "koa-compress": "^5.1.1",
+    "koa-morgan": "^1.0.1",
+    "lint-staged": "^15.2.0",
+    "nodemon": "^3.0.3",
+    "nyc": "^15.1.0",
+    "remark-cli": "11",
+    "remark-preset-github": "^4.0.4",
+    "xo": "^0.56.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/forwardemail/caldav-adapter",
+  "keywords": [
+    "caldav",
+    "calendar",
+    "card",
+    "carddav",
+    "dav",
+    "express",
+    "fastify",
+    "ical",
+    "koa",
+    "web",
+    "webdav"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/forwardemail/caldav-adapter.git"
+  },
+  "scripts": {
+    "lint": "xo --fix && remark . -qfo && fixpack",
+    "prepare": "husky install",
+    "pretest": "npm run lint",
+    "test": "npm run test-coverage",
+    "test-coverage": "cross-env NODE_ENV=test nyc ava"
   }
 }

package/routes/calendar/calendar/calendar-multiget.js

@@ -0,0 +1,48 @@
+const _ = require('lodash');
+const xml = require('../../../common/xml');
+const { response, status } = require('../../../common/x-build');
+const winston = require('../../../common/winston');
+
+module.exports = function (options) {
+  const log = winston({
+    ...options,
+    label: 'calendar/report/calendar-multiget'
+  });
+
+  return async function (ctx, calendar) {
+    const hrefs = xml.get('/CAL:calendar-multiget/D:href', ctx.request.xml);
+    const eventActions = _.map(hrefs, async (node) => {
+      const href = node.textContent;
+      if (!href) {
+        return response(href, status[404]);
+      }
+
+      const hrefParts = href.split('/');
+      const eventId = hrefParts.at(-1).slice(0, -4);
+      const event = await options.data.getEvent({
+        eventId,
+        principalId: ctx.state.params.principalId,
+        calendarId: ctx.state.params.calendarId,
+        user: ctx.state.user,
+        fullData: true
+      });
+      log.debug(`event ${event ? 'found' : 'missing'}: ${eventId}`);
+      if (!event) {
+        return response(href, status[404]);
+      }
+
+      const ics = await options.data.buildICS(event, calendar);
+      return response(href, status[200], [
+        {
+          'D:getetag': options.data.getETag(event)
+        },
+        {
+          'CAL:calendar-data': ics
+        }
+      ]);
+    });
+
+    const responses = await Promise.all(eventActions);
+    return { responses };
+  };
+};

package/routes/calendar/calendar/calendar-query.js

@@ -0,0 +1,80 @@
+const _ = require('lodash');
+const moment = require('moment');
+const xml = require('../../../common/xml');
+const calEventResponse = require('./event-response');
+
+module.exports = function (options) {
+  // const log = winston({ ...opts, label: 'calendar/report/calendar-query' });
+  const eventResponse = calEventResponse(options);
+  return async function (ctx, calendar) {
+    /* https://tools.ietf.org/html/rfc4791#section-9.9 */
+    const filters = xml.get(
+      "/CAL:calendar-query/CAL:filter/CAL:comp-filter[@name='VCALENDAR']/CAL:comp-filter[@name='VEVENT']/CAL:time-range",
+      ctx.request.xml
+    );
+    const { children } = xml.getWithChildren(
+      '/CAL:calendar-query/D:prop',
+      ctx.request.xml
+    );
+    const fullData = _.some(children, (child) => {
+      return child.localName === 'calendar-data';
+    });
+
+    if (!filters?.[0]) {
+      const events = await options.data.getEventsForCalendar({
+        principalId: ctx.state.params.principalId,
+        calendarId: options.data.getCalendarId(calendar),
+        user: ctx.state.user,
+        fullData
+      });
+
+      return eventResponse(ctx, events, calendar, children);
+    }
+
+    //
+    // TODO: support rest of calendar-query
+    // <https://datatracker.ietf.org/doc/html/rfc4791#section-7.8>
+    //
+    // TODO: support multiple filters and missing filters:
+    //
+    // <https://datatracker.ietf.org/doc/html/rfc4791#section-9.7>
+    // - [ ] 9.7.1.  CALDAV:comp-filter XML Element . . . . . . . . . . . . 85
+    // - [ ] 9.7.2.  CALDAV:prop-filter XML Element . . . . . . . . . . . . 86
+    // - [ ] 9.7.3.  CALDAV:param-filter XML Element  . . . . . . . . . . . 87
+    // - [ ] 9.7.4.  CALDAV:is-not-defined XML Element  . . . . . . . . . . 88
+    // - [ ] 9.7.5.  CALDAV:text-match XML Element  . . . . . . . . . . . . 88
+    //
+    // TODO: what else (?)
+    //
+
+    const filter = filters[0];
+    const startAttr = _.find(filter.attributes, { localName: 'start' });
+    const endAttr = _.find(filter.attributes, { localName: 'end' });
+
+    //
+    // rudimentary validation
+    //
+    let start = null;
+    let end = null;
+
+    if (
+      startAttr &&
+      startAttr.nodeValue &&
+      moment(startAttr.nodeValue).isValid()
+    )
+      start = moment(startAttr.nodeValue).toDate();
+
+    if (endAttr && endAttr.nodeValue && moment(endAttr.nodeValue).isValid())
+      end = moment(endAttr.nodeValue).toDate();
+
+    const events = await options.data.getEventsByDate({
+      principalId: ctx.state.params.principalId,
+      calendarId: options.data.getCalendarId(calendar),
+      start,
+      end,
+      user: ctx.state.user,
+      fullData
+    });
+    return eventResponse(ctx, events, calendar, children);
+  };
+};

package/routes/calendar/calendar/delete.js

@@ -0,0 +1,40 @@
+const { notFound } = require('../../../common/x-build');
+const { setMissingMethod } = require('../../../common/response');
+const winston = require('../../../common/winston');
+
+/* https://tools.ietf.org/html/rfc2518#section-8.6 */
+module.exports = function (options) {
+  const log = winston({ ...options, label: 'calendar/delete' });
+  const exec = async function (ctx, calendar) {
+    if (calendar.readonly) {
+      setMissingMethod(ctx);
+      return;
+    }
+
+    if (!ctx.state.params.eventId) {
+      log.warn('eventId param not present');
+      ctx.body = notFound(ctx.url); // Make more meaningful
+      return;
+    }
+
+    const existing = await options.data.getEvent({
+      eventId: ctx.state.params.eventId,
+      principalId: ctx.state.params.principalId,
+      calendarId: ctx.state.params.calendarId,
+      user: ctx.state.user,
+      fullData: false
+    });
+    log.debug(`existing event${existing ? '' : ' not'} found`);
+
+    await options.data.deleteEvent({
+      eventId: ctx.state.params.eventId,
+      principalId: ctx.state.params.principalId,
+      calendarId: ctx.state.params.calendarId,
+      user: ctx.state.user
+    });
+  };
+
+  return {
+    exec
+  };
+};

package/routes/calendar/calendar/event-response.js

@@ -0,0 +1,37 @@
+const path = require('node:path');
+const _ = require('lodash');
+const {
+  response,
+  status,
+  missingPropstats
+} = require('../../../common/x-build');
+const commonTags = require('../../../common/tags');
+
+module.exports = function (options) {
+  const tags = commonTags(options);
+
+  return async function (ctx, events, calendar, children) {
+    const eventActions = _.map(events, async (event) => {
+      const misses = [];
+      const propActions = _.map(children, async (child) => {
+        return tags.getResponse({
+          resource: 'event',
+          child,
+          ctx,
+          calendar,
+          event
+        });
+      });
+      const pRes = await Promise.all(propActions);
+      const url = path.join(ctx.url, `${event.eventId}.ics`);
+      const resp = response(url, status[200], _.compact(pRes));
+      if (misses.length > 0) {
+        resp['D:propstat'].push(missingPropstats(misses));
+      }
+
+      return resp;
+    });
+    const responses = await Promise.all(eventActions);
+    return { responses };
+  };
+};

package/routes/calendar/calendar/expand-property.js

@@ -0,0 +1,11 @@
+const { response, status } = require('../../../common/x-build');
+const winston = require('../../../common/winston');
+
+module.exports = function (options) {
+  const log = winston({ ...options, label: 'calendar/report/expand-property' });
+  return async function (ctx) {
+    // ,calendar
+    log.debug('returning blank 200 response');
+    return { responses: [response(ctx.url, status[200])] };
+  };
+};

package/routes/calendar/calendar/get.js

@@ -0,0 +1,27 @@
+const { setMissingMethod } = require('../../../common/response');
+const winston = require('../../../common/winston');
+
+module.exports = function (options) {
+  const log = winston({ ...options, label: 'calendar/get' });
+
+  const exec = async function (ctx, calendar) {
+    const event = await options.data.getEvent({
+      eventId: ctx.state.params.eventId,
+      principalId: ctx.state.params.principalId,
+      calendarId: ctx.state.params.calendarId,
+      user: ctx.state.user,
+      fullData: true
+    });
+    if (!event) {
+      log.debug(`event ${ctx.state.params.eventId} not found`);
+      setMissingMethod(ctx);
+      return;
+    }
+
+    return options.data.buildICS(event, calendar);
+  };
+
+  return {
+    exec
+  };
+};

package/routes/calendar/calendar/propfind.js

@@ -0,0 +1,73 @@
+const path = require('node:path');
+const _ = require('lodash');
+const xml = require('../../../common/xml');
+const {
+  build,
+  multistatus,
+  response,
+  status
+} = require('../../../common/x-build');
+const commonTags = require('../../../common/tags');
+const calEventResponse = require('./event-response');
+
+module.exports = function (options) {
+  const tags = commonTags(options);
+  const eventResponse = calEventResponse(options);
+
+  const calendarResponse = async function (ctx, calendar) {
+    const { children } = xml.getWithChildren(
+      '/D:propfind/D:prop',
+      ctx.request.xml
+    );
+    const actions = _.map(children, async (child) => {
+      return tags.getResponse({
+        resource: 'calendar',
+        child,
+        ctx,
+        calendar
+      });
+    });
+    const res = await Promise.all(actions);
+
+    const calendarUrl = path.join(
+      ctx.state.calendarHomeUrl,
+      options.data.getCalendarId(calendar),
+      '/'
+    );
+    const props = _.compact(res);
+    return response(
+      calendarUrl,
+      props.length > 0 ? status[200] : status[404],
+      props
+    );
+  };
+
+  const exec = async function (ctx, calendar) {
+    const resp = await calendarResponse(ctx, calendar);
+    const resps = [resp];
+
+    const { children } = xml.getWithChildren(
+      '/D:propfind/D:prop',
+      ctx.request.xml
+    );
+    const fullData = _.some(children, (child) => {
+      return child.localName === 'calendar-data';
+    });
+    const events = await options.data.getEventsForCalendar({
+      principalId: ctx.state.params.principalId,
+      calendarId: options.data.getCalendarId(calendar),
+      user: ctx.state.user,
+      fullData
+    });
+    const { responses } = await eventResponse(ctx, events, calendar, children);
+    resps.push(...responses);
+
+    const ms = multistatus(resps);
+    return build(ms);
+  };
+
+  return {
+    exec,
+    calendarResponse
+  };
+};

package/routes/calendar/calendar/proppatch.js

@@ -0,0 +1,32 @@
+const _ = require('lodash');
+const xml = require('../../../common/xml');
+const { build, multistatus } = require('../../../common/x-build');
+const commonTags = require('../../../common/tags');
+
+module.exports = function (options) {
+  const tags = commonTags(options);
+
+  const exec = async function (ctx, calendar) {
+    const { children } = xml.getWithChildren(
+      '/D:propertyupdate/D:set/D:prop',
+      ctx.request.xml
+    );
+
+    const actions = _.map(children, async (child) => {
+      return tags.getResponse({
+        resource: 'calendarProppatch',
+        child,
+        ctx,
+        calendar
+      });
+    });
+    const res = await Promise.all(actions);
+
+    const ms = multistatus(_.compact(res));
+    return build(ms);
+  };
+
+  return {
+    exec
+  };
+};