@oxy.so/core 1.0.0

package/src/utils/__tests__/profileLinks.test.ts

@@ -0,0 +1,180 @@
+import { normalizeProfileLinks, type ProfileLink } from '../profileLinks';
+
+describe('normalizeProfileLinks', () => {
+  describe('linksMetadata path (preferred)', () => {
+    it('maps title + url and uses the entry id when present', () => {
+      const result = normalizeProfileLinks([
+        { url: 'https://oxy.so', title: 'Oxy', id: 'abc' },
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: 'abc', title: 'Oxy', url: 'https://oxy.so' },
+      ]);
+    });
+
+    it('falls back to the index when an entry has no id', () => {
+      const result = normalizeProfileLinks([
+        { url: 'https://a.example', title: 'A' },
+        { url: 'https://b.example', title: 'B' },
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', title: 'A', url: 'https://a.example' },
+        { id: '1', title: 'B', url: 'https://b.example' },
+      ]);
+    });
+
+    it('omits title when absent', () => {
+      const result = normalizeProfileLinks([{ url: 'https://no-title.example' }]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', url: 'https://no-title.example' },
+      ]);
+      expect(result[0]).not.toHaveProperty('title');
+    });
+
+    it('carries through description and image when present', () => {
+      const result = normalizeProfileLinks([
+        {
+          url: 'https://oxy.so',
+          title: 'Oxy',
+          description: 'The Oxy ecosystem',
+          image: 'https://cdn.example/oxy.png',
+          id: 'abc',
+        },
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        {
+          id: 'abc',
+          title: 'Oxy',
+          url: 'https://oxy.so',
+          description: 'The Oxy ecosystem',
+          image: 'https://cdn.example/oxy.png',
+        },
+      ]);
+    });
+
+    it('omits description and image when absent', () => {
+      const result = normalizeProfileLinks([
+        { url: 'https://min.example', title: 'Min' },
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', title: 'Min', url: 'https://min.example' },
+      ]);
+      expect(result[0]).not.toHaveProperty('description');
+      expect(result[0]).not.toHaveProperty('image');
+    });
+
+    it('carries description and image independently of title', () => {
+      const result = normalizeProfileLinks([
+        { url: 'https://only-image.example', image: 'https://cdn.example/i.png' },
+        { url: 'https://only-desc.example', description: 'Just a description' },
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', url: 'https://only-image.example', image: 'https://cdn.example/i.png' },
+        { id: '1', url: 'https://only-desc.example', description: 'Just a description' },
+      ]);
+      expect(result[0]).not.toHaveProperty('title');
+      expect(result[0]).not.toHaveProperty('description');
+      expect(result[1]).not.toHaveProperty('title');
+      expect(result[1]).not.toHaveProperty('image');
+    });
+
+    it('drops entries with missing or empty url and keeps stable index ids', () => {
+      const result = normalizeProfileLinks([
+        { url: 'https://keep.example', title: 'Keep', id: 'keep' },
+        { url: '', title: 'Empty' },
+        { url: '   ', title: 'Whitespace' },
+        { url: 'https://second.example', title: 'Second' },
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: 'keep', title: 'Keep', url: 'https://keep.example' },
+        // index is preserved from the source array position (3), not re-numbered
+        { id: '3', title: 'Second', url: 'https://second.example' },
+      ]);
+    });
+
+    it('trims surrounding whitespace from urls', () => {
+      const result = normalizeProfileLinks([{ url: '  https://trim.example  ' }]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', url: 'https://trim.example' },
+      ]);
+    });
+
+    it('does NOT add a scheme to bare urls', () => {
+      const result = normalizeProfileLinks([{ url: 'oxy.so', title: 'Bare' }]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', title: 'Bare', url: 'oxy.so' },
+      ]);
+    });
+  });
+
+  describe('legacy links path (no linksMetadata)', () => {
+    it('maps strings to { id, url } without title/description/image', () => {
+      const result = normalizeProfileLinks(undefined, [
+        'https://a.example',
+        'https://b.example',
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', url: 'https://a.example' },
+        { id: '1', url: 'https://b.example' },
+      ]);
+      expect(
+        result.every(
+          (link) =>
+            !('title' in link) &&
+            !('description' in link) &&
+            !('image' in link),
+        ),
+      ).toBe(true);
+    });
+
+    it('drops empty and whitespace-only strings, preserving source index ids', () => {
+      const result = normalizeProfileLinks(undefined, [
+        'https://keep.example',
+        '',
+        '   ',
+        'https://second.example',
+      ]);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', url: 'https://keep.example' },
+        { id: '3', url: 'https://second.example' },
+      ]);
+    });
+  });
+
+  describe('fall-through and empty inputs', () => {
+    it('returns [] when both inputs are absent', () => {
+      expect(normalizeProfileLinks()).toEqual([]);
+      expect(normalizeProfileLinks(undefined, undefined)).toEqual([]);
+    });
+
+    it('returns [] when both inputs are empty arrays', () => {
+      expect(normalizeProfileLinks([], [])).toEqual([]);
+    });
+
+    it('falls through to legacy links when linksMetadata is empty', () => {
+      const result = normalizeProfileLinks([], ['https://legacy.example']);
+      expect(result).toEqual<ProfileLink[]>([
+        { id: '0', url: 'https://legacy.example' },
+      ]);
+    });
+
+    it('returns [] (does NOT fall back to links) when linksMetadata is non-empty but every entry is dropped', () => {
+      const result = normalizeProfileLinks(
+        [{ url: '' }, { url: '   ' }],
+        ['https://legacy.example'],
+      );
+      expect(result).toEqual([]);
+    });
+  });
+
+  it('is pure — does not mutate its inputs', () => {
+    const linksMetadata = [{ url: 'https://oxy.so', title: 'Oxy', id: 'abc' }];
+    const links = ['https://legacy.example'];
+    const metadataSnapshot = JSON.stringify(linksMetadata);
+    const linksSnapshot = JSON.stringify(links);
+
+    normalizeProfileLinks(linksMetadata, links);
+
+    expect(JSON.stringify(linksMetadata)).toBe(metadataSnapshot);
+    expect(JSON.stringify(links)).toBe(linksSnapshot);
+  });
+});

package/src/utils/__tests__/redactUrl.test.ts

@@ -0,0 +1,33 @@
+/**
+ * `redactUrlQuery` tests — the query-string scrubber used before any asset URL
+ * reaches a log sink. Asset stream URLs carry a scoped `mt=` media token that
+ * is a bearer credential; it must never be logged.
+ */
+
+import { redactUrlQuery } from '../redactUrl';
+
+describe('redactUrlQuery', () => {
+  it('strips the query string (including a media token) from an absolute URL', () => {
+    const redacted = redactUrlQuery(
+      'https://api.oxy.so/assets/priv1/stream?variant=thumb&mt=SECRET-TOKEN',
+    );
+    expect(redacted).toBe('https://api.oxy.so/assets/priv1/stream?<redacted>');
+    expect(redacted).not.toContain('mt=');
+    expect(redacted).not.toContain('SECRET-TOKEN');
+  });
+
+  it('strips the query string from a relative path too', () => {
+    expect(redactUrlQuery('/assets/priv1/url?expiresIn=600&mt=SECRET')).toBe(
+      '/assets/priv1/url?<redacted>',
+    );
+  });
+
+  it('returns a URL without a query string unchanged', () => {
+    expect(redactUrlQuery('https://cloud.oxy.so/pub1')).toBe('https://cloud.oxy.so/pub1');
+    expect(redactUrlQuery('/assets')).toBe('/assets');
+  });
+
+  it('passes through empty input', () => {
+    expect(redactUrlQuery('')).toBe('');
+  });
+});

package/src/utils/__tests__/registrableApex.test.ts

@@ -0,0 +1,62 @@
+/**
+ * `registrableApex` — the eTLD+1 host kernel (Public Suffix List aware).
+ *
+ * The client `autoDetectAuthWebUrl` helper was removed in the device-first
+ * cutover; only the registrable-apex kernel survives (used by the api SSO
+ * surface + the IdP). These cases lock its Public-Suffix-List behaviour.
+ */
+
+import { registrableApex } from '../registrableApex';
+
+describe('registrableApex', () => {
+  it('returns the eTLD+1 for a normal two-label host', () => {
+    expect(registrableApex('mention.earth')).toBe('mention.earth');
+  });
+
+  it('strips subdomains down to the trailing two labels', () => {
+    expect(registrableApex('www.mention.earth')).toBe('mention.earth');
+    expect(registrableApex('deep.app.homiio.com')).toBe('homiio.com');
+  });
+
+  it('lower-cases the input', () => {
+    expect(registrableApex('WWW.Mention.EARTH')).toBe('mention.earth');
+  });
+
+  it('returns the eTLD+1 for hosts under multi-part public suffixes', () => {
+    expect(registrableApex('foo.co.uk')).toBe('foo.co.uk');
+    expect(registrableApex('www.foo.co.uk')).toBe('foo.co.uk');
+    expect(registrableApex('shop.victim.com.tr')).toBe('victim.com.tr');
+  });
+
+  it('returns the eTLD+1 for hosts under private hosted suffixes', () => {
+    expect(registrableApex('honest.github.io')).toBe('honest.github.io');
+    expect(registrableApex('app.victim.pages.dev')).toBe('victim.pages.dev');
+    expect(registrableApex('site.victim.netlify.app')).toBe('victim.netlify.app');
+  });
+
+  it('returns null for bare public and private suffixes', () => {
+    expect(registrableApex('co.uk')).toBeNull();
+    expect(registrableApex('github.io')).toBeNull();
+    expect(registrableApex('pages.dev')).toBeNull();
+    expect(registrableApex('netlify.app')).toBeNull();
+  });
+
+  it('returns null for IPv4 literals', () => {
+    expect(registrableApex('192.168.1.10')).toBeNull();
+    expect(registrableApex('10.0.0.1')).toBeNull();
+  });
+
+  it('returns null for IPv6 literals and hosts carrying a port', () => {
+    expect(registrableApex('[::1]')).toBeNull();
+    expect(registrableApex('mention.earth:3000')).toBeNull();
+  });
+
+  it('returns null for single-label hosts', () => {
+    expect(registrableApex('intranet')).toBeNull();
+    expect(registrableApex('localhost')).toBeNull();
+  });
+
+  it('returns null for empty input', () => {
+    expect(registrableApex('')).toBeNull();
+  });
+});

package/src/utils/__tests__/textNormalization.test.ts

@@ -0,0 +1,205 @@
+import { normalizeInlineText, normalizeMultilineText } from '../textNormalization';
+
+/**
+ * Whitespace characters are built from their code points rather than pasted as
+ * literals: an NBSP or a U+2028 in the source would be invisible to a reviewer
+ * and trivially "fixed" by an editor, silently gutting the test it anchors.
+ */
+const NBSP = String.fromCharCode(0x00a0); // no-break space
+const EN_QUAD = String.fromCharCode(0x2000); // U+2000 space block
+const IDEOGRAPHIC_SPACE = String.fromCharCode(0x3000); // CJK full-width space
+const NARROW_NBSP = String.fromCharCode(0x202f);
+const ZWNBSP = String.fromCharCode(0xfeff); // BOM when leading
+const LINE_SEPARATOR = String.fromCharCode(0x2028);
+const PARAGRAPH_SEPARATOR = String.fromCharCode(0x2029);
+
+/** "é" as a base letter plus a combining acute accent (NFD form). */
+const DECOMPOSED_E_ACUTE = `e${String.fromCharCode(0x0301)}`;
+/** The precomposed "é" (NFC form) the two above must normalize into. */
+const COMPOSED_E_ACUTE = String.fromCharCode(0x00e9);
+
+describe('normalizeInlineText', () => {
+  it('flattens the indented multi-line <title> that caused the original bug', () => {
+    expect(normalizeInlineText('\n      Mi título\n    ')).toBe('Mi título');
+  });
+
+  it('collapses every whitespace form to a single space', () => {
+    expect(normalizeInlineText('a\tb\nc\r\nd  e')).toBe('a b c d e');
+  });
+
+  it('collapses Unicode spaces (NBSP, U+2000 block, ideographic, narrow NBSP)', () => {
+    expect(
+      normalizeInlineText(`a${NBSP}b${EN_QUAD}c${IDEOGRAPHIC_SPACE}d${NARROW_NBSP}e`)
+    ).toBe('a b c d e');
+  });
+
+  it('collapses the Unicode line and paragraph separators', () => {
+    expect(normalizeInlineText(`a${LINE_SEPARATOR}b${PARAGRAPH_SEPARATOR}c`)).toBe('a b c');
+  });
+
+  it('strips a leading BOM / zero-width no-break space', () => {
+    expect(normalizeInlineText(`${ZWNBSP}Título`)).toBe('Título');
+  });
+
+  it('handles CRLF line endings', () => {
+    expect(normalizeInlineText('News\r\n\r\nToday')).toBe('News Today');
+  });
+
+  it('returns an empty string for empty and whitespace-only input', () => {
+    expect(normalizeInlineText('')).toBe('');
+    expect(normalizeInlineText('   ')).toBe('');
+    expect(normalizeInlineText(`\n\t ${NBSP}\r\n`)).toBe('');
+  });
+
+  it('NFC-normalizes so decomposed accents are stored composed', () => {
+    const normalized = normalizeInlineText(`Ren${DECOMPOSED_E_ACUTE}e`);
+    expect(normalized).toBe(`Ren${COMPOSED_E_ACUTE}e`);
+    expect(normalized).toHaveLength(5);
+  });
+
+  it('leaves already-clean text untouched', () => {
+    expect(normalizeInlineText('Hacker News')).toBe('Hacker News');
+    expect(normalizeInlineText('Título en español — con guion')).toBe(
+      'Título en español — con guion'
+    );
+  });
+
+  it('does not truncate long values (length caps are a product rule)', () => {
+    const long = 'a'.repeat(500);
+    expect(normalizeInlineText(long)).toHaveLength(500);
+  });
+
+  it('does not strip markup or punctuation (that is the sanitizer\'s job)', () => {
+    expect(normalizeInlineText('  <b>Bold</b> & "quoted"  ')).toBe('<b>Bold</b> & "quoted"');
+  });
+
+  it('is idempotent', () => {
+    const inputs = [
+      '\n      Mi título\n    ',
+      `a${NBSP}${NBSP}b`,
+      'Hacker News',
+      '',
+      '   ',
+      `Ren${DECOMPOSED_E_ACUTE}e`,
+    ];
+    for (const input of inputs) {
+      const once = normalizeInlineText(input);
+      expect(normalizeInlineText(once)).toBe(once);
+    }
+  });
+});
+
+describe('normalizeMultilineText', () => {
+  it('preserves the author\'s paragraphs', () => {
+    const body = 'First paragraph.\n\nSecond paragraph.\nSame paragraph, next line.';
+    expect(normalizeMultilineText(body)).toBe(body);
+  });
+
+  it('collapses a blank line that contains spaces — the ordering bug', () => {
+    // The "blank" lines hold spaces, so they break the run of \n characters: a
+    // bare /\n{3,}/ collapse never sees them. Trailing horizontal whitespace
+    // must be stripped FIRST.
+    expect(normalizeMultilineText('a\n    \n    \nb')).toBe('a\n\nb');
+  });
+
+  it('collapses a blank line that contains tabs and NBSP', () => {
+    expect(normalizeMultilineText(`a\n\t\n${NBSP}${NBSP}\nb`)).toBe('a\n\nb');
+  });
+
+  it('strips trailing horizontal whitespace from every line', () => {
+    expect(normalizeMultilineText('one   \ntwo\t\nthree ')).toBe('one\ntwo\nthree');
+  });
+
+  it('collapses three or more newlines to a single blank line', () => {
+    expect(normalizeMultilineText('a\n\n\n\n\nb')).toBe('a\n\nb');
+  });
+
+  it('keeps exactly one blank line as-is', () => {
+    expect(normalizeMultilineText('a\n\nb')).toBe('a\n\nb');
+  });
+
+  it('collapses runs of horizontal whitespace to one space, keeping newlines', () => {
+    expect(normalizeMultilineText('hello    world\nsecond\t\tline')).toBe(
+      'hello world\nsecond line'
+    );
+  });
+
+  it('strips leading horizontal whitespace from every line', () => {
+    expect(normalizeMultilineText('a\n b')).toBe('a\nb');
+    expect(normalizeMultilineText('one\n\ttwo\n      three')).toBe('one\ntwo\nthree');
+  });
+
+  it('leaves no indent residue after a space-filled blank line', () => {
+    // The blank line collapses AND the six-space indent goes away entirely —
+    // collapsing it to a single space would leave a visible artifact under
+    // `white-space: pre-wrap`.
+    expect(normalizeMultilineText('Hola\n    \n\n      Mundo')).toBe('Hola\n\nMundo');
+  });
+
+  it('normalizes CRLF and lone CR to \\n', () => {
+    expect(normalizeMultilineText('a\r\nb\rc')).toBe('a\nb\nc');
+    expect(normalizeMultilineText('a\r\n\r\n\r\n\r\nb')).toBe('a\n\nb');
+  });
+
+  it('normalizes the Unicode line and paragraph separators to \\n', () => {
+    expect(normalizeMultilineText(`a${LINE_SEPARATOR}b${PARAGRAPH_SEPARATOR}c`)).toBe('a\nb\nc');
+  });
+
+  it('collapses Unicode spaces without touching line structure', () => {
+    expect(normalizeMultilineText(`a${NBSP}${NBSP}b\nc${IDEOGRAPHIC_SPACE}d`)).toBe('a b\nc d');
+  });
+
+  it('trims both ends, including leading and trailing blank lines', () => {
+    expect(normalizeMultilineText('\n\n  Hello\n\nWorld  \n\n  ')).toBe('Hello\n\nWorld');
+  });
+
+  it('returns an empty string for empty and whitespace-only input', () => {
+    expect(normalizeMultilineText('')).toBe('');
+    expect(normalizeMultilineText('   ')).toBe('');
+    expect(normalizeMultilineText(`\n\n \t${NBSP}\r\n  \n`)).toBe('');
+  });
+
+  it('NFC-normalizes so decomposed accents are stored composed', () => {
+    expect(normalizeMultilineText(`Caf${DECOMPOSED_E_ACUTE}\n\nabierto`)).toBe(
+      `Caf${COMPOSED_E_ACUTE}\n\nabierto`
+    );
+  });
+
+  it('leaves an already-clean body untouched', () => {
+    const body = 'Line one\nLine two\n\nNew paragraph.';
+    expect(normalizeMultilineText(body)).toBe(body);
+  });
+
+  it('cleans a realistic federated post body without losing its paragraphs', () => {
+    const federated = '  Hola a todos.\r\n   \r\n\r\nEsto  es  una   prueba.\t\r\nFin.   ';
+    expect(normalizeMultilineText(federated)).toBe(
+      'Hola a todos.\n\nEsto es una prueba.\nFin.'
+    );
+  });
+
+  it('is idempotent', () => {
+    const inputs = [
+      'a\n    \n    \nb',
+      'a\r\n\r\n\r\nb',
+      'First paragraph.\n\nSecond paragraph.',
+      `a${NBSP}b`,
+      'a\n b',
+      'Hola\n    \n\n      Mundo',
+      '',
+      '   ',
+      `Caf${DECOMPOSED_E_ACUTE}`,
+    ];
+    for (const input of inputs) {
+      const once = normalizeMultilineText(input);
+      expect(normalizeMultilineText(once)).toBe(once);
+    }
+  });
+});
+
+describe('choosing between the two helpers', () => {
+  it('inline flattens what multiline preserves', () => {
+    const body = 'Title\n\nSubtitle';
+    expect(normalizeInlineText(body)).toBe('Title Subtitle');
+    expect(normalizeMultilineText(body)).toBe('Title\n\nSubtitle');
+  });
+});