@dxos/plugin-magazine 0.0.0

package/src/operations/sources/feed-fetcher.test.ts

@@ -0,0 +1,200 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { afterEach, beforeEach, describe, test, vi } from 'vitest';
+
+import { EffectEx } from '@dxos/effect';
+
+import { fetchStandardSite, listStandardSitePublications, parseStandardSiteActor } from './standard-site';
+
+// The Standard.site fetchers are Effects (they provide their own HTTP layer); run them for assertions.
+// `fetchStandardSite` now takes the publication site reference (`at://` or `https://`) as `url`.
+const runFetchStandardSite = (url: string) => EffectEx.runPromise(fetchStandardSite(url));
+
+// RSS/Atom coverage lives in rss.test.ts.
+
+// Sample Standard.site read chain: resolveHandle → plc.directory (DID doc) → listRecords → getProfile →
+// getRecord (publication). One document references its publication by `at://` URI, the other by a bare
+// `https://` URL (resolved directly, no getRecord needed).
+const DID = 'did:plc:abc123';
+const PDS = 'https://pds.example.com';
+const PUBLICATION_URI = `at://${DID}/site.standard.publication/self`;
+
+const DID_DOCUMENT = {
+  service: [{ id: '#atproto_pds', type: 'AtprotoPersonalDataServer', serviceEndpoint: PDS }],
+};
+
+const PROFILE = {
+  did: DID,
+  handle: 'alice.example.com',
+  displayName: 'Alice',
+  avatar: 'https://example.com/avatar.jpg',
+  description: 'Long-form writing.',
+};
+
+const PUBLICATION = {
+  uri: PUBLICATION_URI,
+  value: { url: 'https://alice.example.com/', name: 'Alice Blog' },
+};
+
+const LIST_RECORDS = {
+  records: [
+    {
+      uri: `at://${DID}/site.standard.document/doc1`,
+      value: {
+        site: PUBLICATION_URI,
+        title: 'First Article',
+        path: '/blog/first',
+        description: 'A first long-form post.',
+        content: { $type: 'site.standard.content.markdown', text: '# First\n\nBody text.', version: '1.0' },
+        textContent: 'First Body text.',
+        publishedAt: '2026-01-02T00:00:00Z',
+        tags: ['echo'],
+      },
+    },
+    {
+      uri: `at://${DID}/site.standard.document/doc2`,
+      value: {
+        site: 'https://alice.example.com',
+        title: 'Older Article',
+        path: '/blog/older',
+        content: { $type: 'site.standard.content.markdown', text: '# Older' },
+        publishedAt: '2026-01-01T00:00:00Z',
+      },
+    },
+  ],
+};
+
+describe('FeedFetcher', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  describe('fetchStandardSite', () => {
+    test('takes an at:// publication reference, fetches only matching documents', async ({ expect }) => {
+      globalThis.fetch = routedFetch();
+
+      // `url` is the publication site reference; DID is extracted directly from the at:// URI.
+      const result = await runFetchStandardSite(PUBLICATION_URI);
+
+      expect(result.feed.type).toBe('standard-site');
+      // Feed name and url come from the publication record; icon/description from the author profile.
+      expect(result.feed.name).toBe('Alice Blog');
+      expect(result.feed.url).toBe(PUBLICATION_URI);
+      expect(result.feed.iconUrl).toBe('https://example.com/avatar.jpg');
+      expect(result.feed.description).toBe('Long-form writing.');
+
+      // Only the document whose `site` matches PUBLICATION_URI is included.
+      expect(result.posts).toHaveLength(1);
+      const [first] = result.posts;
+      expect(first.title).toBe('First Article');
+      expect(first.link).toBe('https://alice.example.com/blog/first');
+      expect(first.content).toBe('# First\n\nBody text.');
+      expect(first.description).toBe('A first long-form post.');
+      expect(first.author).toBe('Alice');
+      expect(first.published).toBe('2026-01-02T00:00:00Z');
+      expect(first.guid).toBe(`at://${DID}/site.standard.document/doc1`);
+    });
+
+    test('takes an https:// publication reference, resolves DID via /.well-known/atproto-did', async ({ expect }) => {
+      const mockFetch = routedFetch();
+      globalThis.fetch = mockFetch;
+
+      // The https:// site reference triggers a /.well-known/atproto-did lookup for the DID.
+      const result = await runFetchStandardSite('https://alice.example.com');
+
+      const calls = mockFetch.mock.calls.map((call) => String(call[0]));
+      expect(calls.some((url) => url.includes('/.well-known/atproto-did'))).toBe(true);
+      expect(calls.some((url) => url.includes('resolveHandle'))).toBe(false);
+
+      // The document whose `site` is 'https://alice.example.com' is the only match.
+      expect(result.posts).toHaveLength(1);
+      expect(result.posts[0].title).toBe('Older Article');
+    });
+
+    test('fails on a non-ok response', async ({ expect }) => {
+      globalThis.fetch = vi.fn().mockResolvedValue(new Response(null, { status: 404, statusText: 'Not Found' }));
+
+      await expect(runFetchStandardSite(PUBLICATION_URI)).rejects.toThrow(/Fetch failed/);
+    });
+  });
+
+  describe('listStandardSitePublications', () => {
+    test('lists the distinct publications a handle publishes under', async ({ expect }) => {
+      globalThis.fetch = routedFetch();
+
+      const publications = await EffectEx.runPromise(listStandardSitePublications('alice.example.com'));
+
+      // One `at://` publication (resolved via getRecord) and one bare `https://` site.
+      expect(publications).toHaveLength(2);
+      const bySite = new Map(publications.map((publication) => [publication.site, publication]));
+      expect(bySite.get(PUBLICATION_URI)?.name).toBe('Alice Blog');
+      expect(bySite.get('https://alice.example.com')?.url).toBe('https://alice.example.com');
+    });
+  });
+
+  describe('parseStandardSiteActor', () => {
+    test('extracts handle from bsky.app URL', ({ expect }) => {
+      expect(parseStandardSiteActor('https://bsky.app/profile/alice.bsky.social')).toBe('alice.bsky.social');
+    });
+
+    test('extracts handle from bsky.app URL with trailing path', ({ expect }) => {
+      expect(parseStandardSiteActor('https://bsky.app/profile/alice.bsky.social/post/abc')).toBe('alice.bsky.social');
+    });
+
+    test('passes through bare handle', ({ expect }) => {
+      expect(parseStandardSiteActor('dxos.org')).toBe('dxos.org');
+    });
+
+    test('strips leading @ from handle', ({ expect }) => {
+      expect(parseStandardSiteActor('@alice.bsky.social')).toBe('alice.bsky.social');
+    });
+
+    test('passes through DID', ({ expect }) => {
+      expect(parseStandardSiteActor('did:plc:abc123')).toBe('did:plc:abc123');
+    });
+  });
+});
+
+// Helpers
+
+const okJson = (data: unknown) =>
+  new Response(JSON.stringify(data), { status: 200, headers: { 'content-type': 'application/json' } });
+
+/**
+ * Routes a mocked `fetch` by endpoint so the resolution chain is order-independent.
+ * `fetchStandardSite` takes a site reference as `url`:
+ *   - `at://did:plc:abc123/…` → extract DID → plc.directory → listRecords → getProfile → getRecord
+ *   - `https://alice.example.com` → /.well-known/atproto-did → plc.directory → listRecords → getProfile
+ */
+const routedFetch = () =>
+  vi.fn(async (input: unknown) => {
+    const url = String(input);
+    if (url.includes('/.well-known/atproto-did')) {
+      return okJson({ did: DID });
+    }
+    if (url.includes('resolveHandle')) {
+      return okJson({ did: DID });
+    }
+    if (url.includes('plc.directory')) {
+      return okJson(DID_DOCUMENT);
+    }
+    if (url.includes('listRecords')) {
+      return okJson(LIST_RECORDS);
+    }
+    if (url.includes('getProfile')) {
+      return okJson(PROFILE);
+    }
+    if (url.includes('getRecord')) {
+      return okJson(PUBLICATION);
+    }
+    throw new Error(`Unexpected fetch URL: ${url}`);
+  });

package/src/operations/sources/feed-fetcher.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Data from 'effect/Data';
+import type * as Effect from 'effect/Effect';
+
+import { type Subscription } from '#types';
+
+export type FetchOptions = {
+  corsProxy?: string;
+};
+
+export type FetchResult = {
+  feed: Subscription.Subscription;
+  posts: Subscription.Post[];
+};
+
+/** Failure fetching or decoding a feed (network error, non-2xx response, or malformed body). */
+export class FeedFetchError extends Data.TaggedError('FeedFetchError')<{
+  message: string;
+  cause?: unknown;
+}> {}
+
+/** Generic feed fetcher — protocol-specific implementations return normalized Subscription objects. */
+export type FeedFetcher = (url: string, options?: FetchOptions) => Effect.Effect<FetchResult, FeedFetchError>;

package/src/operations/sources/http.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as HttpClientResponse from '@effect/platform/HttpClientResponse';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import type * as Schema from 'effect/Schema';
+
+import { applyCorsProxy } from './cors';
+import { FeedFetchError } from './feed-fetcher';
+
+// Short, bounded retry so a transient hiccup doesn't fail a fetch, without stalling the form.
+const retryPolicy = Schedule.exponential('500 millis').pipe(Schedule.compose(Schedule.recurs(2)));
+
+/** GETs a URL (through the optional CORS proxy) and decodes the JSON body against `schema`. */
+export const getJson = <A, I>(
+  schema: Schema.Schema<A, I>,
+  url: string,
+  proxy?: string,
+): Effect.Effect<A, FeedFetchError, HttpClient.HttpClient> =>
+  HttpClientRequest.get(applyCorsProxy(url, proxy)).pipe(
+    HttpClient.execute,
+    Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+    Effect.timeout('10 seconds'),
+    Effect.retry(retryPolicy),
+    Effect.scoped,
+    Effect.mapError((cause) => new FeedFetchError({ message: `Fetch failed: ${url}`, cause })),
+  );
+
+/** GETs a URL (through the optional CORS proxy) and returns the response body as text. */
+export const getText = (url: string, proxy?: string): Effect.Effect<string, FeedFetchError, HttpClient.HttpClient> =>
+  HttpClientRequest.get(applyCorsProxy(url, proxy)).pipe(
+    HttpClient.execute,
+    Effect.flatMap((response) => response.text),
+    Effect.timeout('10 seconds'),
+    Effect.retry(retryPolicy),
+    Effect.scoped,
+    Effect.mapError((cause) => new FeedFetchError({ message: `Fetch failed: ${url}`, cause })),
+  );

package/src/operations/sources/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './article';
+export * from './cors';
+export * from './feed-fetcher';
+export * from './rss';
+export * from './standard-site';

package/src/operations/sources/rss.test.ts

@@ -0,0 +1,201 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { afterEach, beforeEach, describe, test, vi } from 'vitest';
+
+import { EffectEx } from '@dxos/effect';
+
+import { fetchRss } from './rss';
+// Real-world RSS feed (CDATA-wrapped summary + content:encoded HTML), loaded via Vite's `?raw` suffix.
+import FEED_XML from './testing/feed.xml?raw';
+
+// `fetchRss` is an Effect (it provides its own HTTP layer); run it to a promise for assertions.
+const runFetchRss = (url: string, options?: { corsProxy?: string }) => EffectEx.runPromise(fetchRss(url, options));
+
+// Sample RSS XML fixture.
+const RSS_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>Test RSS Feed</title>
+    <description>A test feed.</description>
+    <link>https://example.com</link>
+    <item>
+      <title>First Post</title>
+      <link>https://example.com/post-1</link>
+      <description>Description of first post.</description>
+      <author>Alice</author>
+      <pubDate>2025-01-15T12:00:00Z</pubDate>
+      <guid>post-1</guid>
+    </item>
+    <item>
+      <title>Second Post</title>
+      <link>https://example.com/post-2</link>
+      <description>Description of second post.</description>
+      <author>Bob</author>
+      <pubDate>2025-01-14T12:00:00Z</pubDate>
+      <guid>post-2</guid>
+    </item>
+  </channel>
+</rss>`;
+
+// Sample Atom XML fixture.
+const ATOM_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>Test Atom Feed</title>
+  <subtitle>An Atom test feed.</subtitle>
+  <entry>
+    <title>Atom Entry One</title>
+    <link rel="alternate" href="https://example.com/atom-1"/>
+    <summary>Summary of atom entry one.</summary>
+    <author><name>Charlie</name></author>
+    <published>2025-02-01T10:00:00Z</published>
+    <id>atom-entry-1</id>
+  </entry>
+</feed>`;
+
+const mockFetchOnce = (body: string) => {
+  globalThis.fetch = vi
+    .fn()
+    .mockResolvedValue(new Response(body, { status: 200, headers: { 'content-type': 'application/rss+xml' } }));
+};
+
+describe('fetchRss', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  test('parses RSS feed into Subscription objects', async ({ expect }) => {
+    mockFetchOnce(RSS_XML);
+
+    const result = await runFetchRss('https://example.com/rss');
+
+    expect(result.feed.name).toBe('Test RSS Feed');
+    expect(result.feed.description).toBe('A test feed.');
+    expect(result.posts).toHaveLength(2);
+    expect(result.posts[0].title).toBe('First Post');
+    expect(result.posts[0].author).toBe('Alice');
+    expect(result.posts[0].guid).toBe('post-1');
+    expect(result.posts[1].title).toBe('Second Post');
+    expect(result.posts[1].guid).toBe('post-2');
+  });
+
+  test('parses Atom feed into Subscription objects', async ({ expect }) => {
+    mockFetchOnce(ATOM_XML);
+
+    const result = await runFetchRss('https://example.com/atom');
+
+    expect(result.feed.name).toBe('Test Atom Feed');
+    expect(result.feed.description).toBe('An Atom test feed.');
+    expect(result.posts).toHaveLength(1);
+    expect(result.posts[0].title).toBe('Atom Entry One');
+    expect(result.posts[0].author).toBe('Charlie');
+    expect(result.posts[0].guid).toBe('atom-entry-1');
+    expect(result.posts[0].link).toBe('https://example.com/atom-1');
+  });
+
+  test('extracts text from RSS elements that carry attributes', async ({ expect }) => {
+    const xmlWithAttrs = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title type="text">Feed With Attrs</title>
+    <description xml:lang="en">Feed description.</description>
+    <item>
+      <title type="html">Post With Attrs</title>
+      <link>https://example.com/post-3</link>
+      <description type="html">Post &amp; body.</description>
+      <author>Dana</author>
+      <pubDate>2025-05-10T12:00:00Z</pubDate>
+      <guid isPermaLink="false">post-3</guid>
+    </item>
+  </channel>
+</rss>`;
+    mockFetchOnce(xmlWithAttrs);
+
+    const result = await runFetchRss('https://example.com/rss');
+
+    expect(result.feed.name).toBe('Feed With Attrs');
+    expect(result.feed.description).toBe('Feed description.');
+    expect(result.posts).toHaveLength(1);
+    expect(result.posts[0].title).toBe('Post With Attrs');
+    expect(result.posts[0].description).toBe('Post & body.');
+    expect(result.posts[0].author).toBe('Dana');
+    expect(result.posts[0].guid).toBe('post-3');
+    expect(result.posts[0].link).toBe('https://example.com/post-3');
+  });
+
+  test('handles deeply nested HTML in description without exceeding parser limits', async ({ expect }) => {
+    // Build nested HTML 200 levels deep — well past fast-xml-parser's default 100-tag cap.
+    let nested = 'leaf';
+    for (let index = 0; index < 200; index++) {
+      nested = `<div>${nested}</div>`;
+    }
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>Nested HTML Feed</title>
+    <description>Feed.</description>
+    <item>
+      <title>Nested Post</title>
+      <link>https://example.com/nested</link>
+      <description>${nested}</description>
+      <guid>nested-1</guid>
+    </item>
+  </channel>
+</rss>`;
+    mockFetchOnce(xml);
+
+    const result = await runFetchRss('https://example.com/rss');
+
+    expect(result.posts).toHaveLength(1);
+    expect(result.posts[0].title).toBe('Nested Post');
+    expect(result.posts[0].guid).toBe('nested-1');
+  });
+
+  test('uses CORS proxy when provided', async ({ expect }) => {
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValue(new Response(RSS_XML, { status: 200, headers: { 'content-type': 'application/rss+xml' } }));
+    globalThis.fetch = mockFetch;
+
+    await runFetchRss('https://example.com/rss', { corsProxy: '/api/rss?url=' });
+
+    // FetchHttpClient calls `fetch(url, init)`; the test env resolves the relative proxy path to an
+    // absolute URL, so assert the proxied target is contained rather than matching exactly.
+    expect(String(mockFetch.mock.calls[0][0])).toContain(
+      '/api/rss?url=' + encodeURIComponent('https://example.com/rss'),
+    );
+  });
+
+  test('parses a real-world RSS feed, unwrapping CDATA and converting content to markdown', async ({ expect }) => {
+    mockFetchOnce(FEED_XML);
+
+    const result = await runFetchRss('https://www.theregister.com/headlines.atom');
+
+    expect(result.feed.name).toBe('www.theregister.com - Articles');
+    expect(result.feed.description).toBe('Articles from www.theregister.com');
+    expect(result.posts).toHaveLength(25);
+
+    const post = result.posts[0];
+    expect(post.title).toBe("Trump's AI E-(I)-O could let feds pick winners and losers");
+    expect(post.link).toBe(
+      'https://www.theregister.com/ai-and-ml/2026/06/02/trump-ai-executive-order-sets-30-day-frontier-model-review/5250322',
+    );
+    expect(post.guid).toBe('https://www.theregister.com/a/5250322');
+
+    // CDATA-wrapped <description> summary is unwrapped (and trimmed).
+    expect(post.description).toBe("Government gets a say in 'trusted partner' access, and that worries policy experts");
+
+    // <content:encoded> HTML is unwrapped from CDATA and converted to markdown — no raw block tags survive.
+    expect(post.content).toBeDefined();
+    expect(post.content).toContain('After postponing a planned signing');
+    expect(post.content).not.toMatch(/<\/?(p|div|h[1-6]|ul|ol|li|a|span)\b/i);
+  });
+});

package/src/operations/sources/rss.ts

@@ -0,0 +1,138 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as Effect from 'effect/Effect';
+import { XMLParser } from 'fast-xml-parser';
+
+import { normalizeText } from '@dxos/markdown';
+
+import { Subscription } from '#types';
+
+import { decodeEntities } from '../../util/text';
+import { type FeedFetcher, FeedFetchError, type FetchResult } from './feed-fetcher';
+import { getText } from './http';
+
+/**
+ * Unwrap `<![CDATA[ ... ]]>` sections, returning the inner content.
+ * fast-xml-parser returns stopNode'd content (description / summary / content / content:encoded)
+ * verbatim, so CDATA-wrapped HTML — which feeds use pervasively — arrives as a literal
+ * `<![CDATA[ ... ]]>` string. Strip the wrapper(s) so the inner HTML reaches downstream
+ * conversion. A no-op for values that contain no CDATA section.
+ */
+const stripCdata = (value: string): string => value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1');
+
+/**
+ * Normalize a fast-xml-parser value to a plain string.
+ * fast-xml-parser yields objects like `{'#text': 'foo', '@_type': 'html'}` for
+ * elements with attributes, and plain strings/numbers for text-only elements.
+ * Returns undefined for nullish values.
+ *
+ * Entities are decoded explicitly: stopNode'd nodes (description / content /
+ * summary / content:encoded) are returned as raw text by fast-xml-parser,
+ * skipping its built-in entity decoding and CDATA unwrapping. Decoding and
+ * CDATA stripping here keep callers from having to special-case those fields.
+ * For non-stopped nodes both are no-ops (the parser has already decoded
+ * entities and there is no CDATA wrapper).
+ */
+const text = (value: unknown): string | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  if (typeof value === 'string') {
+    return decodeEntities(stripCdata(value));
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (typeof value === 'object') {
+    const t = (value as { '#text'?: unknown })['#text'];
+    if (typeof t === 'string') {
+      return decodeEntities(stripCdata(t));
+    }
+    if (typeof t === 'number' || typeof t === 'boolean') {
+      return String(t);
+    }
+  }
+
+  return undefined;
+};
+
+/**
+ * Convert a feed text value to Markdown. Feed description/content/summary fields routinely carry
+ * embedded HTML (escaped or raw); normalizeText converts it to Markdown and passes plaintext
+ * through unchanged. Returns undefined for nullish values.
+ */
+const markdown = (value: string | undefined): string | undefined => (value != null ? normalizeText(value) : undefined);
+
+/** Fetches and parses an RSS/Atom feed URL into Subscription objects. */
+export const fetchRss: FeedFetcher = (url, options) =>
+  Effect.gen(function* () {
+    const xml = yield* getText(url, options?.corsProxy);
+    return yield* Effect.try({
+      try: () => parseFeed(url, xml),
+      catch: (cause) => new FeedFetchError({ message: `Unrecognized feed format: ${url}`, cause }),
+    });
+  }).pipe(Effect.provide(FetchHttpClient.layer));
+
+/** Parses RSS/Atom XML into a normalized {@link FetchResult}; throws on an unrecognized shape. */
+const parseFeed = (url: string, xml: string): FetchResult => {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    // RSS/Atom feeds frequently embed HTML (sometimes un-escaped, without CDATA) in content fields,
+    // which can blow past fast-xml-parser's default 100-tag nesting cap.
+    maxNestedTags: 10_000,
+    // Treat known HTML-bearing fields as opaque text so embedded markup isn't parsed as XML.
+    stopNodes: ['*.description', '*.summary', '*.content', '*.content:encoded'],
+  });
+
+  const parsed = parser.parse(xml);
+  const channel = parsed.rss?.channel ?? parsed.feed;
+  if (!channel) {
+    throw new Error('Unrecognized feed format');
+  }
+
+  const isAtom = !parsed.rss;
+  const feedName = text(channel.title) ?? '';
+  const feedDescription = markdown(text(isAtom ? channel.subtitle : channel.description)) ?? '';
+
+  const items: any[] = (isAtom ? channel.entry : channel.item) ?? [];
+  const itemList = Array.isArray(items) ? items : [items];
+
+  const posts = itemList.map((item) => {
+    const link = isAtom
+      ? ((Array.isArray(item.link)
+          ? item.link.find((l: any) => l['@_rel'] === 'alternate')?.['@_href']
+          : (item.link?.['@_href'] ?? text(item.link))) ?? '')
+      : (text(item.link) ?? '');
+
+    const author = isAtom
+      ? (text(item.author?.name) ?? text(item.author))
+      : (text(item['dc:creator']) ?? text(item.author));
+
+    const description = markdown(text(item.description));
+    const content = isAtom
+      ? (markdown(text(item.summary)) ?? markdown(text(item.content)))
+      : markdown(text(item['content:encoded']));
+
+    return Subscription.makePost({
+      title: text(item.title),
+      link,
+      description,
+      content,
+      author,
+      published: text(item.pubDate) ?? text(item.published) ?? text(item.updated),
+      guid: (isAtom ? text(item.id) : text(item.guid)) ?? link,
+    });
+  });
+
+  const feed = Subscription.makeSubscription({
+    name: feedName,
+    url,
+    description: feedDescription,
+  });
+
+  return { feed, posts };
+};