@rmdes/indiekit-endpoint-posts 1.0.0-beta.25

package/lib/controllers/post.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+
+import { checkScope } from "@indiekit/endpoint-micropub/lib/scope.js";
+
+/**
+ * View published post
+ * @type {import("express").RequestHandler}
+ */
+export const postController = async (request, response) => {
+  const { draftMode, postName, postsPath, postStatus, properties, scope } =
+    response.locals;
+
+  const postEditable = draftMode ? postStatus === "draft" : true;
+
+  response.render("post", {
+    title: postName,
+    parent: {
+      href: postsPath,
+      text: response.locals.__("posts.posts.title"),
+    },
+    actions: [
+      scope &&
+      checkScope(scope, "update") &&
+      !properties.deleted &&
+      postEditable
+        ? {
+            href: path.join(request.baseUrl + request.path, "/update"),
+            icon: "updatePost",
+            text: response.locals.__("posts.update.action"),
+          }
+        : {},
+      scope && checkScope(scope, "delete") && !properties.deleted
+        ? {
+            classes: "actions__link--warning",
+            href: path.join(request.baseUrl + request.path, "/delete"),
+            icon: "delete",
+            text: response.locals.__("posts.delete.action"),
+          }
+        : {},
+      scope && checkScope(scope, "undelete") && properties.deleted
+        ? {
+            href: path.join(request.baseUrl + request.path, "/undelete"),
+            icon: "undelete",
+            text: response.locals.__("posts.undelete.action"),
+          }
+        : {},
+    ],
+    redirectUri: path.join(request.baseUrl, request.params.uid),
+    success: request.query.success,
+  });
+};

package/lib/controllers/posts.js

@@ -0,0 +1,96 @@
+import path from "node:path";
+
+import { checkScope } from "@indiekit/endpoint-micropub/lib/scope.js";
+import { excerpt } from "@indiekit/util";
+import { mf2tojf2 } from "@paulrobertlloyd/mf2tojf2";
+
+import { endpoint } from "../endpoint.js";
+import { statusTypes } from "../status-types.js";
+import { getPostStatusBadges, getPostName, getPhotoUrl } from "../utils.js";
+
+/**
+ * List published posts
+ * @type {import("express").RequestHandler}
+ */
+export const postsController = async (request, response, next) => {
+  try {
+    const { application, publication } = request.app.locals;
+    const { access_token, scope } = request.session;
+    const { after, before, success } = request.query;
+    const limit = Number(request.query.limit) || 12;
+
+    const micropubUrl = new URL(application.micropubEndpoint);
+    micropubUrl.searchParams.append("q", "source");
+    micropubUrl.searchParams.append("limit", String(limit));
+
+    if (after) {
+      micropubUrl.searchParams.append("after", String(after));
+    }
+
+    if (before) {
+      micropubUrl.searchParams.append("before", String(before));
+    }
+
+    const micropubResponse = await endpoint.get(micropubUrl.href, access_token);
+
+    let posts;
+    if (micropubResponse?.items?.length > 0) {
+      const jf2 = mf2tojf2(micropubResponse);
+      const items = jf2.children || [jf2];
+
+      posts = items.map((item) => {
+        item.id = item.uid;
+        item.icon = item["post-type"];
+        item.locale = application.locale;
+        item.photo = getPhotoUrl(publication, item);
+        item.description = {
+          text:
+            item.summary ||
+            (item.content?.text &&
+              excerpt(item.content.text, 30, publication.locale)),
+        };
+        item.title = getPostName(publication, item);
+        item.url = path.join(request.baseUrl, request.path, item.uid);
+        item.badges = getPostStatusBadges(item, response);
+
+        return item;
+      });
+    }
+
+    const cursor = {};
+
+    if (micropubResponse?.paging?.after) {
+      cursor.next = {
+        href: `?after=${micropubResponse.paging.after}`,
+      };
+    }
+
+    if (micropubResponse?.paging?.before) {
+      cursor.previous = {
+        href: `?before=${micropubResponse.paging.before}`,
+      };
+    }
+
+    response.render("posts", {
+      title: response.locals.__("posts.posts.title"),
+      actions: [
+        scope && checkScope(scope, "create")
+          ? {
+              href: path.join(request.baseUrl + request.path, "/new"),
+              icon: "createPost",
+              text: response.locals.__("posts.create.action"),
+            }
+          : {},
+      ],
+      cursor,
+      posts,
+      limit,
+      count: micropubResponse._count,
+      parentUrl: request.baseUrl + request.path,
+      statusTypes,
+      success,
+    });
+  } catch (error) {
+    next(error);
+  }
+};

package/lib/endpoint.js

@@ -0,0 +1,53 @@
+import { IndiekitError } from "@indiekit/error";
+
+export const endpoint = {
+  /**
+   * Micropub query
+   * @param {string} url - URL
+   * @param {string} accessToken - Access token
+   * @returns {Promise<object>} Response data
+   */
+  async get(url, accessToken) {
+    const endpointResponse = await fetch(url, {
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    if (!endpointResponse.ok) {
+      throw await IndiekitError.fromFetch(endpointResponse);
+    }
+
+    const body = await endpointResponse.json();
+
+    return body;
+  },
+
+  /**
+   * Micropub action
+   * @param {string} url - URL
+   * @param {string} accessToken - Access token
+   * @param {object} [jsonBody] - JSON body
+   * @returns {Promise<object>} Response data
+   */
+  async post(url, accessToken, jsonBody = false) {
+    const endpointResponse = await fetch(url, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${accessToken}`,
+        ...(jsonBody && { "content-type": "application/json" }),
+      },
+      ...(jsonBody && { body: JSON.stringify(jsonBody) }),
+    });
+
+    if (!endpointResponse.ok) {
+      throw await IndiekitError.fromFetch(endpointResponse);
+    }
+
+    return endpointResponse.status === 204
+      ? { success_description: endpointResponse.headers.get("location") }
+      : await endpointResponse.json();
+  },
+};

package/lib/middleware/post-data.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+
+import { IndiekitError } from "@indiekit/error";
+
+import { statusTypes } from "../status-types.js";
+import {
+  getChannelItems,
+  getGeoValue,
+  getPostName,
+  getPostProperties,
+  getSyndicateToItems,
+} from "../utils.js";
+
+export const postData = {
+  create(request, response, next) {
+    const { publication } = request.app.locals;
+    const { access_token, scope } = request.session;
+
+    // Create new post object with default values
+    const postType = request.query.type || "note";
+    const properties = request.body || {};
+
+    // Get post type config
+    const { name, fields, h } = publication.postTypes[postType];
+
+    // Only select ‘checked’ syndication targets on first view
+    const checkTargets = Object.entries(properties).length === 0;
+
+    response.locals = {
+      accessToken: access_token,
+      action: "create",
+      channelItems: getChannelItems(publication),
+      fields,
+      name,
+      postsPath: path.dirname(request.baseUrl + request.path),
+      postType,
+      properties,
+      scope,
+      showAdvancedOptions: false,
+      syndicationTargetItems: getSyndicateToItems(publication, checkTargets),
+      type: h,
+      ...response.locals,
+    };
+
+    next();
+  },
+
+  async read(request, response, next) {
+    try {
+      const { application, publication } = request.app.locals;
+      const { action, uid } = request.params;
+      const { access_token, scope } = request.session;
+
+      const properties = await getPostProperties(
+        uid,
+        application.micropubEndpoint,
+        access_token,
+      );
+
+      if (!properties) {
+        throw IndiekitError.notFound(response.locals.__("NotFoundError.page"));
+      }
+
+      const allDay = properties?.start && !properties.start.includes("T");
+      const geo = properties?.location && getGeoValue(properties.location);
+      const postType = properties["post-type"];
+
+      // Get post type config
+      const { name, fields, h } = publication.postTypes[postType];
+
+      response.locals = {
+        accessToken: access_token,
+        action: action || "create",
+        allDay,
+        channelItems: getChannelItems(publication),
+        draftMode: scope?.includes("draft"),
+        fields,
+        geo,
+        h,
+        name,
+        postName: getPostName(publication, properties),
+        postsPath: path.dirname(request.baseUrl + request.path),
+        postStatus: properties["post-status"],
+        postType,
+        properties,
+        scope,
+        showAdvancedOptions: true,
+        syndicationTargetItems: getSyndicateToItems(publication),
+        statusTypes,
+        ...response.locals,
+      };
+
+      next();
+    } catch (error) {
+      next(error);
+    }
+  },
+};

package/lib/middleware/validation.js

@@ -0,0 +1,23 @@
+import { check, checkSchema } from "express-validator";
+
+export const validate = {
+  async form(request, response, next) {
+    const { validationSchemas } = request.app.locals;
+    const validations = [];
+
+    for (const schema of [Object.fromEntries(validationSchemas)]) {
+      validations.push(checkSchema(schema));
+    }
+
+    for (let validation of validations) {
+      await validation.run(request);
+    }
+
+    next();
+  },
+  new: [
+    check("type")
+      .exists()
+      .withMessage((value, { req }) => req.__("posts.error.type.empty")),
+  ],
+};

package/lib/status-types.js

@@ -0,0 +1,32 @@
+export const statusTypes = {
+  deleted: {
+    color: "red",
+    text: "posts.status.deleted",
+  },
+  draft: {
+    color: "offset",
+    text: "posts.status.draft",
+  },
+  private: {
+    color: "offset-purple",
+    icon: "publicOff",
+    text: "posts.status.private",
+  },
+  public: {
+    color: "offset-purple",
+    icon: "public",
+    text: "posts.status.public",
+  },
+  published: {
+    color: "purple",
+    text: "posts.status.published",
+  },
+  syndicated: {
+    text: "posts.status.syndicated",
+  },
+  unlisted: {
+    color: "offset-purple",
+    icon: "unlisted",
+    text: "posts.status.unlisted",
+  },
+};

package/lib/utils.js

@@ -0,0 +1,201 @@
+import { Buffer } from "node:buffer";
+
+import { sanitise, ISO_6709_RE } from "@indiekit/util";
+import { mf2tojf2 } from "@paulrobertlloyd/mf2tojf2";
+import formatcoords from "formatcoords";
+
+import { endpoint } from "./endpoint.js";
+import { statusTypes } from "./status-types.js";
+
+/**
+ * Get channel `items` for checkboxes component
+ * @param {object} publication - Publication configuration
+ * @returns {object} Items for checkboxes component
+ */
+export const getChannelItems = (publication) => {
+  return Object.entries(publication.channels).map(([uid, channel]) => ({
+    label: channel.name,
+    value: uid,
+  }));
+};
+
+/**
+ * Get geographic coordinates property
+ * @param {string} geo - Latitude and longitude, comma separated
+ * @returns {object} JF2 geo location property
+ */
+export const getGeoProperty = (geo) => {
+  const { latitude, longitude } = geo.match(ISO_6709_RE).groups;
+
+  return {
+    type: "geo",
+    name: formatcoords(geo).format({
+      decimalPlaces: 2,
+    }),
+    latitude: Number(latitude),
+    longitude: Number(longitude),
+  };
+};
+
+/**
+ * Get comma separated geographic coordinates
+ * @param {object} location - JF2 location property
+ * @returns {string|undefined} Latitude and longitude, comma separated
+ */
+export const getGeoValue = (location) => {
+  if (location && location.geo) {
+    return [location.geo.latitude, location.geo.longitude].toString();
+  } else if (location && location.type === "geo") {
+    return [location.latitude, location.longitude].toString();
+  }
+};
+
+/**
+ * Get location property
+ * @param {object} values - Latitude and longitude, comma separated
+ * @returns {object} JF2 location property
+ */
+export const getLocationProperty = (values) => {
+  const { geo, location } = values;
+
+  const hasGeo = geo && geo.length > 0;
+  const hasLocation = location && Object.entries(sanitise(location)).length > 0;
+
+  // Determine Microformat type
+  if (hasLocation && location.name) {
+    location.type = "card";
+  } else if (hasLocation && !hasGeo) {
+    location.type = "adr";
+  }
+
+  // Add (or use) any provided geo location properties
+  if (hasLocation && hasGeo) {
+    location.geo = getGeoProperty(geo);
+  } else if (hasGeo) {
+    return getGeoProperty(geo);
+  }
+
+  return sanitise(location);
+};
+
+/**
+ * Get photo URL
+ * @param {object} publication - Publication configuration
+ * @param {object} properties - JF2 properties
+ * @returns {object|boolean} Photo object, with URL
+ */
+export const getPhotoUrl = (publication, properties) => {
+  const photo = Array.isArray(properties.photo)
+    ? properties.photo[0]
+    : properties.photo;
+
+  if (!photo) {
+    return false;
+  } else if (URL.canParse(photo.url)) {
+    return photo;
+  } else {
+    return {
+      url: new URL(photo.url, publication.me).href,
+    };
+  }
+};
+
+/**
+ * Get post status badges
+ * @param {object} post - Post
+ * @param {import("express").Response} response - Response
+ * @returns {Array} Badges
+ */
+export const getPostStatusBadges = (post, response) => {
+  const badges = [];
+
+  if (post["post-status"]) {
+    const statusType = post["post-status"];
+    badges.push({
+      color: statusTypes[statusType].color,
+      size: "small",
+      text: response.locals.__(statusTypes[statusType].text),
+    });
+  }
+
+  if (post.deleted) {
+    badges.push({
+      color: statusTypes.deleted.color,
+      size: "small",
+      text: response.locals.__(statusTypes.deleted.text),
+    });
+  }
+
+  return badges;
+};
+
+/**
+ * Get post name, falling back to post type name
+ * @param {object} publication - Publication configuration
+ * @param {object} properties - JF2 properties
+ * @returns {string} Post name or post type name
+ */
+export const getPostName = (publication, properties) => {
+  if (properties.name) {
+    return properties.name;
+  }
+
+  const type = properties["post-type"];
+  const { name } = publication.postTypes[type];
+
+  return name;
+};
+
+/**
+ * Query Micropub endpoint for post data
+ * @param {string} uid - Item UID
+ * @param {string} micropubEndpoint - Micropub endpoint
+ * @param {string} accessToken - Access token
+ * @returns {Promise<object>} JF2 properties
+ */
+export const getPostProperties = async (uid, micropubEndpoint, accessToken) => {
+  const micropubUrl = new URL(micropubEndpoint);
+  micropubUrl.searchParams.append("q", "source");
+
+  const micropubResponse = await endpoint.get(micropubUrl.href, accessToken);
+
+  if (micropubResponse?.items?.length > 0) {
+    const jf2 = mf2tojf2(micropubResponse);
+    const items = jf2.children || [jf2];
+    return items.find((item) => item.uid === uid);
+  }
+
+  return false;
+};
+
+/**
+ * Get post URL from ID
+ * @param {string} id - ID
+ * @returns {string} Post URL
+ */
+export const getPostUrl = (id) => {
+  const url = Buffer.from(id, "base64url").toString("utf8");
+  return new URL(url).href;
+};
+
+/**
+ * Get syndication target `items` for checkboxes component
+ * @param {object} publication - Publication configuration
+ * @param {boolean} [checkTargets] - Select ’checked’ targets
+ * @returns {object} Items for checkboxes component
+ */
+export const getSyndicateToItems = (publication, checkTargets = false) => {
+  return publication.syndicationTargets.map((target) => ({
+    label: target.info.service.name,
+    ...(target?.info?.error
+      ? {
+          disabled: true,
+          hint: target?.info?.error || false,
+        }
+      : {
+          hint: target?.info.uid,
+          value: target?.info.uid,
+          ...(checkTargets && { checked: target.options.checked }),
+        }),
+  }));
+};

package/locales/de.json

@@ -0,0 +1,127 @@
+{
+  "posts": {
+    "create": {
+      "action": "Neuer Beitrag",
+      "title": "Einen neuen %s-Beitrag erstellen"
+    },
+    "delete": {
+      "action": "Beitrag löschen",
+      "cancel": "Nein — zurück zur Post",
+      "submit": "Ich bin mir sicher — lösche diesen Beitrag",
+      "title": "Möchtest du diesen Beitrag wirklich löschen?"
+    },
+    "error": {
+      "content": {
+        "empty": "Geben Sie einige Inhalte ein"
+      },
+      "featured-alt": {
+        "empty": "Geben Sie eine Beschreibung dieses Bildes ein"
+      },
+      "geo": {
+        "invalid": "Geben Sie gültige Koordinaten ein"
+      },
+      "media": {
+        "empty": "Geben Sie einen Dateipfad oder eine Webadresse wie %s ein"
+      },
+      "name": {
+        "empty": "Titel eingeben"
+      },
+      "type": {
+        "empty": "Wählen Sie einen Beitragstyp"
+      },
+      "url": {
+        "empty": "Geben Sie eine Webadresse wie %s"
+      }
+    },
+    "form": {
+      "advancedOptions": "Erweiterte Optionen",
+      "back": "Beitragstyp ändern",
+      "cancel": "Abbrechen",
+      "category": {
+        "hint": "Trennen Sie jede Kategorie durch ein Komma",
+        "label": "Kategorien",
+        "tag": "Kategorie"
+      },
+      "content": {
+        "label": "Inhalt"
+      },
+      "continue": "Fortsetzen",
+      "featured": {
+        "alt": "Barrierefreie Beschreibung",
+        "label": "Ausgewähltes Bild"
+      },
+      "geo": {
+        "hint": "Breitengrad und Längengrad, zum Beispiel %s",
+        "label": "Koordinaten des Standorts"
+      },
+      "location": {
+        "country-name": "Land",
+        "label": "Standort",
+        "locality": "Stadt oder Ort",
+        "name": "Veranstaltungsort",
+        "postal-code": "Postleitzahl",
+        "street-address": "Straße"
+      },
+      "media": {
+        "label": "Dateipfad oder URL"
+      },
+      "mp-channel": {
+        "label": "Kanal"
+      },
+      "mp-slug": {
+        "label": "Slug"
+      },
+      "mp-syndicate-to": {
+        "label": "Syndikat zu"
+      },
+      "name": {
+        "label": "Titel"
+      },
+      "publish": "Beitrag veröffentlichen",
+      "publishDraft": "Entwurf speichern",
+      "published": {
+        "label": "Veröffentlichungsdatum",
+        "now": "Jetzt",
+        "scheduled": "Bestimmtes Datum und Uhrzeit"
+      },
+      "summary": {
+        "label": "Übersicht"
+      },
+      "update": "Beitrag aktualisieren",
+      "updateDraft": "Entwurf aktualisieren",
+      "visibility": {
+        "label": "Sichtbarkeit"
+      }
+    },
+    "new": {
+      "title": "Welche Art von Beitrag möchtest du erstellen?"
+    },
+    "post": {
+      "properties": "Eigenschaften",
+      "syndicate": "Syndikatsposten"
+    },
+    "posts": {
+      "none": "Keine Beiträge",
+      "title": "Veröffentlichte Beiträge"
+    },
+    "status": {
+      "deleted": "Gelöscht",
+      "draft": "Entwurf",
+      "private": "Privat",
+      "public": "Öffentlich",
+      "published": "Veröffentlicht",
+      "syndicated": "Syndiziert",
+      "unlisted": "Nicht gelistete"
+    },
+    "title": "Beiträge",
+    "undelete": {
+      "action": "Beitrag wiederherstellen",
+      "submit": "Ich bin sicher – diesen Beitrag wiederherstellen",
+      "title": "Möchten Sie diesen Beitrag wirklich wiederherstellen?"
+    },
+    "update": {
+      "action": "Beitrag bearbeiten",
+      "title": "%s-Beitrag aktualisieren"
+    }
+  }
+}