caldav-adapter 4.3.1 → 5.0.1

package/common/tags.js

@@ -0,0 +1,412 @@
+const { buildTag, href, response, status } = require('./x-build');
+const winston = require('./winston');
+
+const dav = 'DAV:';
+const cal = 'urn:ietf:params:xml:ns:caldav';
+const cs = 'http://calendarserver.org/ns/';
+const ical = 'http://apple.com/ns/ical/';
+
+module.exports = function (options) {
+  const log = winston({ ...options, label: 'tags' });
+  const tags = {
+    [dav]: {
+      'current-user-principal': {
+        doc: 'https://tools.ietf.org/html/rfc5397#section-3',
+        async resp({ ctx }) {
+          return {
+            [buildTag(dav, 'current-user-principal')]: href(
+              ctx.state.principalUrl
+            )
+          };
+        }
+      },
+      'current-user-privilege-set': {
+        doc: 'https://tools.ietf.org/html/rfc3744#section-5.4',
+        async resp({ resource, calendar }) {
+          if (resource === 'calendar') {
+            const privileges = [{ [buildTag(dav, 'read')]: '' }];
+            if (!calendar.readonly) {
+              privileges.push(
+                { [buildTag(dav, 'read')]: '' },
+                { [buildTag(dav, 'read-acl')]: '' },
+                { [buildTag(dav, 'read-current-user-privilege-set')]: '' },
+                { [buildTag(dav, 'write')]: '' },
+                { [buildTag(dav, 'write-content')]: '' },
+                { [buildTag(dav, 'write-properties')]: '' },
+                { [buildTag(dav, 'bind')]: '' }, // PUT - https://tools.ietf.org/html/rfc3744#section-3.9
+                { [buildTag(dav, 'unbind')]: '' }, // DELETE - https://tools.ietf.org/html/rfc3744#section-3.10
+                { [buildTag(cal, 'read-free-busy')]: '' } // https://tools.ietf.org/html/rfc4791#section-6.1.1
+              );
+            }
+
+            return {
+              [buildTag(dav, 'current-user-privilege-set')]: {
+                [buildTag(dav, 'privilege')]: privileges
+              }
+            };
+          }
+        }
+      },
+      displayname: {
+        doc: 'https://tools.ietf.org/html/rfc4918#section-15.2',
+        async resp({ resource, ctx, calendar }) {
+          if (resource === 'principal') {
+            return {
+              [buildTag(dav, 'displayname')]: ctx.state.user.principalName
+            };
+          }
+
+          if (resource === 'calendar') {
+            return {
+              [buildTag(dav, 'displayname')]: calendar.name
+            };
+          }
+        }
+      },
+      getcontenttype: {
+        doc: 'https://tools.ietf.org/html/rfc2518#section-13.5',
+        async resp({ resource }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(dav, 'getcontenttype')]:
+                'text/calendar; charset=utf-8; component=VEVENT'
+            };
+          }
+
+          if (resource === 'event') {
+            return {
+              [buildTag(dav, 'getcontenttype')]:
+                'text/calendar; charset=utf-8; component=VEVENT'
+            };
+          }
+        }
+      },
+      getetag: {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-5.3.4',
+        async resp({ resource, event }) {
+          if (resource === 'event') {
+            return {
+              [buildTag(dav, 'getetag')]: options.data.getETag(event)
+            };
+          }
+        }
+      },
+      owner: {
+        doc: 'https://tools.ietf.org/html/rfc3744#section-5.1',
+        async resp({ resource, ctx }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(dav, 'owner')]: href(ctx.state.principalUrl)
+            };
+          }
+        }
+      },
+      'principal-collection-set': {
+        doc: 'https://tools.ietf.org/html/rfc3744#section-5.8',
+        async resp({ resource, ctx }) {
+          if (resource === 'principal') {
+            return {
+              [buildTag(dav, 'principal-collection-set')]: href(
+                ctx.state.principalRootUrl
+              )
+            };
+          }
+        }
+      },
+      'principal-URL': {
+        doc: 'https://tools.ietf.org/html/rfc3744#section-4.2',
+        async resp({ ctx }) {
+          return {
+            [buildTag(dav, 'principal-URL')]: href(ctx.state.principalUrl)
+          };
+        }
+      },
+      'resource-id': {
+        doc: 'https://tools.ietf.org/html/rfc5842#section-3.1'
+      },
+      resourcetype: {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-4.2',
+        async resp({ resource }) {
+          if (resource === 'calCollection') {
+            return {
+              [buildTag(dav, 'resourcetype')]: {
+                [buildTag(dav, 'collection')]: ''
+              }
+            };
+          }
+
+          if (resource === 'calendar') {
+            return {
+              [buildTag(dav, 'resourcetype')]: {
+                [buildTag(dav, 'collection')]: '',
+                [buildTag(cal, 'calendar')]: ''
+              }
+            };
+          }
+        }
+      },
+      'supported-report-set': {
+        doc: 'https://tools.ietf.org/html/rfc3253#section-3.1.5',
+        async resp({ resource }) {
+          if (resource === 'calCollection') {
+            return {
+              [buildTag(dav, 'supported-report-set')]: {
+                [buildTag(dav, 'supported-report')]: {
+                  [buildTag(dav, 'report')]: {
+                    [buildTag(cal, 'sync-collection')]: ''
+                  }
+                }
+              }
+            };
+          }
+
+          if (resource === 'calendar') {
+            return {
+              [buildTag(dav, 'supported-report-set')]: {
+                [buildTag(dav, 'supported-report')]: [
+                  {
+                    [buildTag(dav, 'report')]: {
+                      [buildTag(cal, 'calendar-query')]: ''
+                    }
+                  },
+                  {
+                    [buildTag(dav, 'report')]: {
+                      [buildTag(cal, 'calendar-multiget')]: ''
+                    }
+                  },
+                  {
+                    [buildTag(dav, 'report')]: {
+                      [buildTag(cal, 'sync-collection')]: ''
+                    }
+                  }
+                ]
+              }
+            };
+          }
+        }
+      },
+      'sync-token': {
+        doc: 'https://tools.ietf.org/html/rfc6578#section-3',
+        async resp({ resource, calendar }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(dav, 'sync-token')]: calendar.synctoken
+            };
+          }
+        }
+      }
+    },
+    [cal]: {
+      'calendar-data': {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-9.6',
+        async resp({ event, calendar }) {
+          const ics = await options.data.buildICS(event, calendar);
+          return {
+            [buildTag(cal, 'calendar-data')]: ics
+          };
+        }
+      },
+      'calendar-home-set': {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-6.2.1',
+        async resp({ resource, ctx }) {
+          if (resource === 'principal') {
+            return {
+              [buildTag(cal, 'calendar-home-set')]: href(
+                ctx.state.calendarHomeUrl
+              )
+            };
+          }
+        }
+      },
+      'calendar-description': {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-5.2.1',
+        async resp({ resource, ctx, calendar }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(ical, 'calendar-description')]: calendar.description
+            };
+          }
+
+          if (resource === 'calendarProppatch') {
+            return response(ctx.url, status[403], [
+              {
+                [buildTag(cal, 'calendar-description')]: ''
+              }
+            ]);
+          }
+        }
+      },
+      'calendar-timezone': {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-5.2.2',
+        async resp({ resource, ctx, calendar }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(ical, 'calendar-timezone')]: calendar.timezone
+            };
+          }
+
+          if (resource === 'calendarProppatch') {
+            return response(ctx.url, status[403], [
+              {
+                [buildTag(cal, 'calendar-timezone')]: ''
+              }
+            ]);
+          }
+        }
+      },
+      'calendar-user-address-set': {
+        doc: 'https://tools.ietf.org/html/rfc6638#section-2.4.1'
+      },
+      'default-alarm-vevent-date': {
+        doc: 'https://tools.ietf.org/id/draft-daboo-valarm-extensions-01.html#rfc.section.9',
+        async resp({ resource, ctx }) {
+          if (resource === 'calCollectionProppatch') {
+            return response(ctx.url, status[403], [
+              {
+                [buildTag(cal, 'default-alarm-vevent-date')]: ''
+              }
+            ]);
+          }
+        }
+      },
+      'default-alarm-vevent-datetime': {
+        doc: 'https://tools.ietf.org/id/draft-daboo-valarm-extensions-01.html#rfc.section.9',
+        async resp({ resource, ctx }) {
+          if (resource === 'calCollectionProppatch') {
+            return response(ctx.url, status[403], [
+              {
+                [buildTag(cal, 'default-alarm-vevent-datetime')]: ''
+              }
+            ]);
+          }
+        }
+      },
+      'schedule-inbox-URL': {
+        doc: 'https://tools.ietf.org/html/rfc6638#section-2.2',
+        async resp() {
+          return {
+            [buildTag(cal, 'schedule-inbox-URL')]: href('')
+          };
+        }
+      },
+      'schedule-outbox-URL': {
+        doc: 'https://tools.ietf.org/html/rfc6638#section-2.1',
+        async resp() {
+          return {
+            [buildTag(cal, 'schedule-outbox-URL')]: href('')
+          };
+        }
+      },
+      'supported-calendar-component-set': {
+        doc: 'https://tools.ietf.org/html/rfc4791#section-5.2.3',
+        async resp({ resource }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(cal, 'supported-calendar-component-set')]: {
+                [buildTag(cal, 'comp')]: {
+                  '@name': 'VEVENT'
+                }
+              }
+            };
+          }
+        }
+      }
+    },
+    [cs]: {
+      'allowed-sharing-modes': {
+        doc: 'https://github.com/apple/ccs-calendarserver/blob/master/doc/Extensions/caldav-sharing.txt',
+        async resp({ resource }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(cs, 'allowed-sharing-modes')]: ''
+            };
+          }
+        }
+      },
+      'checksum-versions': {},
+      'dropbox-home-URL': {},
+      'email-address-set': {},
+      getctag: {
+        // DEPRECATED
+        doc: 'https://github.com/apple/ccs-calendarserver/blob/master/doc/Extensions/caldav-ctag.txt',
+        async resp({ resource, calendar }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(cs, 'getctag')]: calendar.synctoken
+            };
+          }
+        }
+      },
+      'notification-URL': {
+        doc: 'https://github.com/apple/ccs-calendarserver/blob/master/doc/Extensions/caldav-notifications.txt'
+      }
+    },
+    [ical]: {
+      'calendar-color': {
+        async resp({ resource, ctx, calendar }) {
+          if (resource === 'calendar') {
+            return {
+              [buildTag(ical, 'calendar-color')]: calendar.color
+            };
+          }
+
+          if (resource === 'calendarProppatch') {
+            return response(ctx.url, status[403], [
+              {
+                [buildTag(ical, 'calendar-color')]: ''
+              }
+            ]);
+          }
+        }
+      },
+      'calendar-order': {
+        async resp({ resource, ctx }) {
+          if (
+            resource === 'calCollectionProppatch' ||
+            resource === 'calendarProppatch'
+          ) {
+            return response(ctx.url, status[403], [
+              {
+                [buildTag(ical, 'calendar-order')]: ''
+              }
+            ]);
+          }
+        }
+      }
+    }
+  };
+  const getResponse = async ({ resource, child, ctx, calendar, event }) => {
+    if (!child.namespaceURI) {
+      return null;
+    }
+
+    if (!tags[child.namespaceURI]) {
+      log.debug(`Namespace miss: ${child.namespaceURI}`);
+      return null;
+    }
+
+    const tagAction = tags[child.namespaceURI][child.localName];
+
+    if (!tagAction) {
+      log.debug(`Tag miss: ${buildTag(child.namespaceURI, child.localName)}`);
+      return null;
+    }
+
+    if (!tagAction.resp) {
+      log.debug(
+        `Tag no response: ${buildTag(child.namespaceURI, child.localName)}`
+      );
+      return null;
+    }
+
+    return tagAction.resp({
+      resource,
+      ctx,
+      calendar,
+      event,
+      text: child.textContent
+    });
+  };
+
+  return { tags, getResponse };
+};

package/common/winston.js

@@ -0,0 +1,32 @@
+const { format, createLogger, transports } = require('winston');
+
+module.exports = function (options) {
+  const logger = createLogger({
+    level: options.logLevel || 'debug',
+    format: format.combine(
+      format.colorize(),
+      format.timestamp({
+        format: 'YYYY-MM-DD HH:mm:ss:SSS'
+      }),
+      format.label({ label: options.label }),
+      format.align(),
+      format.printf((info) => {
+        return `${info.timestamp} ${info.level} [${info.label}]: ${info.message}`;
+      })
+    )
+  });
+
+  if (options.logEnabled) {
+    logger.add(new transports.Console());
+  } else {
+    logger.silent = true;
+  }
+
+  logger.morganStream = {
+    write(message) {
+      logger.verbose(message.trim());
+    }
+  };
+
+  return logger;
+};

package/common/x-build.js

@@ -0,0 +1,109 @@
+const { create } = require('xmlbuilder2');
+const mapKeys = require('lodash/mapKeys');
+const { nsLookup, namespaces } = require('./xml');
+
+module.exports = {};
+
+const nsMap = function () {
+  return mapKeys(namespaces, (v, k) => {
+    return `@xmlns:${k}`;
+  });
+};
+
+function buildTag(namespaceURI, localName) {
+  return `${nsLookup[namespaceURI]}:${localName}`;
+}
+
+module.exports.buildTag = buildTag;
+
+function href(url) {
+  return { [buildTag('DAV:', 'href')]: url };
+}
+
+module.exports.href = href;
+
+function build(object) {
+  const doc = create(object, {
+    version: '1.0',
+    // eslint-disable-next-line unicorn/text-encoding-identifier-case
+    encoding: 'UTF-8',
+    noDoubleEncoding: true
+  });
+  return doc.end({ prettyPrint: true });
+}
+
+module.exports.build = build;
+
+function multistatus(responses, other) {
+  const res = {
+    [buildTag('DAV:', 'multistatus')]: nsMap()
+  };
+  if (responses?.length) {
+    res[buildTag('DAV:', 'multistatus')][buildTag('DAV:', 'response')] =
+      responses;
+  }
+
+  if (other) {
+    res[buildTag('DAV:', 'multistatus')] = Object.assign(
+      res[buildTag('DAV:', 'multistatus')],
+      other
+    );
+  }
+
+  return res;
+}
+
+module.exports.multistatus = multistatus;
+
+const status = {
+  200: 'HTTP/1.1 200 OK',
+  403: 'HTTP/1.1 403 Forbidden',
+  404: 'HTTP/1.1 404 Not Found'
+};
+module.exports.status = status;
+
+function response(url, status, props) {
+  const res = href(url);
+  res[buildTag('DAV:', 'propstat')] = [
+    {
+      [buildTag('DAV:', 'status')]: status
+    }
+  ];
+  if (props && props.length > 0) {
+    res[buildTag('DAV:', 'propstat')][0][buildTag('DAV:', 'prop')] =
+      Object.assign({}, ...props);
+  }
+
+  return res;
+}
+
+module.exports.response = response;
+
+module.exports.missingPropstats = function (props) {
+  // eslint-disable-next-line unicorn/no-array-reduce
+  return props.reduce(
+    (res, v) => {
+      res[buildTag('DAV:', 'prop')][v] = '';
+      return res;
+    },
+    {
+      [buildTag('DAV:', 'status')]: status[404],
+      [buildTag('DAV:', 'prop')]: {}
+    }
+  );
+};
+
+module.exports.notFound = function (href) {
+  return build(multistatus([response(href, status[404])]));
+};
+
+/* https://tools.ietf.org/html/rfc4791#section-5.3.2.1 */
+module.exports.preconditionFail = function (url, reason) {
+  const res = {
+    'D:error': {
+      [buildTag('urn:ietf:params:xml:ns:caldav', reason)]: url,
+      ...nsMap()
+    }
+  };
+  return build(res);
+};

package/common/xml.js

@@ -0,0 +1,36 @@
+const xpath = require('xpath');
+
+module.exports = {};
+
+const namespaces = {
+  D: 'DAV:',
+  CAL: 'urn:ietf:params:xml:ns:caldav',
+  CS: 'http://calendarserver.org/ns/',
+  ICAL: 'http://apple.com/ns/ical/'
+};
+module.exports.namespaces = namespaces;
+
+const nsLookup = {
+  'DAV:': 'D',
+  'urn:ietf:params:xml:ns:caldav': 'CAL',
+  'http://calendarserver.org/ns/': 'CS',
+  'http://apple.com/ns/ical/': 'ICAL'
+};
+module.exports.nsLookup = nsLookup;
+
+const select = xpath.useNamespaces(namespaces);
+
+function get(path, doc) {
+  return select(path, doc);
+}
+
+module.exports.get = get;
+
+function getWithChildren(path, doc) {
+  const propNode = get(path, doc);
+  // eslint-disable-next-line unicorn/prefer-spread
+  const children = propNode[0] ? Array.from(propNode[0].childNodes) : [];
+  return { propNode, children };
+}
+
+module.exports.getWithChildren = getWithChildren;