@nfcard/validation 0.25.0 → 0.25.1

package/dist/index.js

@@ -643,7 +643,7 @@ function isWebAddress(value) {
 }
 var webAddressSchema = z2.string().refine(isWebAddress, "invalidUrl").optional().or(z2.literal(""));
 function stripUnsafeChars(s) {
-  return s.replace(/[-<>"'`\\]/g, "").trim();
+  return s.replace(/[\x00-\x1f\x7f<>"'`\\]/g, "").trim();
 }
 function sanitizeHttpUrl(raw) {
   if (typeof raw !== "string") return "";
@@ -663,7 +663,7 @@ function sanitizeHttpUrl(raw) {
 }
 function sanitizeText(raw, max = 50) {
   if (typeof raw !== "string") return "";
-  const noTags = raw.replace(/<[^>]*>/g, "").replace(/[-]/g, "");
+  const noTags = raw.replace(/<[^>]*>/g, "").replace(/[\x00-\x1f\x7f]/g, "");
   return noTags.trim().slice(0, max);
 }
 var secureUrl = z2.string().max(2048).optional().or(z2.literal("")).transform((v) => sanitizeHttpUrl(v));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nfcard/validation",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Shared Zod validation schemas for the NFCard product family.",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,7 +17,7 @@
   ],
   "dependencies": {
     "zod": "^3.24.0",
-    "@nfcard/types": "0.19.0"
+    "@nfcard/types": "0.20.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0"

package/src/booking.test.ts

@@ -1,85 +1,85 @@
-import { describe, expect, it } from 'vitest'
-import { bookingSchema, digitalConfigSchema } from './index'
-
-const baseConfig = {
-  templateId: 'classic' as const,
-  accentColor: '#123456',
-  fontKey: 'inter',
-  showAvatar: true,
-}
-
-describe('bookingSchema', () => {
-  it('accepts a valid provider + handle and stores only { provider, handle }', () => {
-    expect(bookingSchema.parse({ provider: 'salonic', handle: 'kiss-fodraszat' })).toEqual({
-      provider: 'salonic',
-      handle: 'kiss-fodraszat',
-    })
-  })
-
-  it('normalizes a pasted booking-page URL down to the subdomain handle', () => {
-    expect(
-      bookingSchema.parse({
-        provider: 'salonic',
-        handle: 'https://kiss-fodraszat.salonic.hu/booking?x=1',
-      }),
-    ).toEqual({ provider: 'salonic', handle: 'kiss-fodraszat' })
-  })
-
-  it('lowercases the handle', () => {
-    expect(bookingSchema.parse({ provider: 'reservio', handle: 'HighBrow' })).toEqual({
-      provider: 'reservio',
-      handle: 'highbrow',
-    })
-  })
-
-  it('keeps a sanitized custom label, capped at 40 chars', () => {
-    const out = bookingSchema.parse({
-      provider: 'salonic',
-      handle: 'kiss-fodraszat',
-      label: '<b>Foglalj</b> ' + 'x'.repeat(60),
-    })
-    expect(out?.provider).toBe('salonic')
-    expect(out?.label).not.toContain('<')
-    expect((out?.label ?? '').length).toBeLessThanOrEqual(40)
-  })
-
-  it('drops everything invalid to undefined instead of throwing (never 400)', () => {
-    expect(bookingSchema.parse(undefined)).toBeUndefined()
-    expect(bookingSchema.parse(null)).toBeUndefined()
-    expect(bookingSchema.parse('nonsense')).toBeUndefined()
-    expect(bookingSchema.parse({})).toBeUndefined()
-    expect(bookingSchema.parse({ provider: 'booksy', handle: 'szalon' })).toBeUndefined()
-    expect(bookingSchema.parse({ provider: 'salonic', handle: 'www' })).toBeUndefined() // reserved
-    expect(bookingSchema.parse({ provider: 'salonic', handle: '-bad' })).toBeUndefined() // bad DNS label
-    expect(
-      bookingSchema.parse({ provider: 'salonic', handle: 'https://evil.com/szalon' }),
-    ).toBeUndefined()
-    expect(
-      bookingSchema.parse({ provider: 'salonic', handle: 'javascript:alert(1)' }),
-    ).toBeUndefined()
-    expect(bookingSchema.parse({ provider: 'salonic', handle: 123 })).toBeUndefined()
-  })
-})
-
-describe('digitalConfigSchema — booking field', () => {
-  it('round-trips a valid booking', () => {
-    const parsed = digitalConfigSchema.parse({
-      ...baseConfig,
-      booking: { provider: 'salonic', handle: 'kiss-fodraszat' },
-    })
-    expect(parsed.booking).toEqual({ provider: 'salonic', handle: 'kiss-fodraszat' })
-  })
-
-  it('drops an invalid booking without failing the whole config save', () => {
-    const parsed = digitalConfigSchema.parse({
-      ...baseConfig,
-      booking: { provider: 'salonic', handle: 'https://evil.com/x' },
-    })
-    expect(parsed.booking).toBeUndefined()
-  })
-
-  it('is optional — a config without a booking parses fine', () => {
-    const parsed = digitalConfigSchema.parse(baseConfig)
-    expect(parsed.booking).toBeUndefined()
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { bookingSchema, digitalConfigSchema } from './index'
+
+const baseConfig = {
+  templateId: 'classic' as const,
+  accentColor: '#123456',
+  fontKey: 'inter',
+  showAvatar: true,
+}
+
+describe('bookingSchema', () => {
+  it('accepts a valid provider + handle and stores only { provider, handle }', () => {
+    expect(bookingSchema.parse({ provider: 'salonic', handle: 'kiss-fodraszat' })).toEqual({
+      provider: 'salonic',
+      handle: 'kiss-fodraszat',
+    })
+  })
+
+  it('normalizes a pasted booking-page URL down to the subdomain handle', () => {
+    expect(
+      bookingSchema.parse({
+        provider: 'salonic',
+        handle: 'https://kiss-fodraszat.salonic.hu/booking?x=1',
+      }),
+    ).toEqual({ provider: 'salonic', handle: 'kiss-fodraszat' })
+  })
+
+  it('lowercases the handle', () => {
+    expect(bookingSchema.parse({ provider: 'reservio', handle: 'HighBrow' })).toEqual({
+      provider: 'reservio',
+      handle: 'highbrow',
+    })
+  })
+
+  it('keeps a sanitized custom label, capped at 40 chars', () => {
+    const out = bookingSchema.parse({
+      provider: 'salonic',
+      handle: 'kiss-fodraszat',
+      label: '<b>Foglalj</b> ' + 'x'.repeat(60),
+    })
+    expect(out?.provider).toBe('salonic')
+    expect(out?.label).not.toContain('<')
+    expect((out?.label ?? '').length).toBeLessThanOrEqual(40)
+  })
+
+  it('drops everything invalid to undefined instead of throwing (never 400)', () => {
+    expect(bookingSchema.parse(undefined)).toBeUndefined()
+    expect(bookingSchema.parse(null)).toBeUndefined()
+    expect(bookingSchema.parse('nonsense')).toBeUndefined()
+    expect(bookingSchema.parse({})).toBeUndefined()
+    expect(bookingSchema.parse({ provider: 'booksy', handle: 'szalon' })).toBeUndefined()
+    expect(bookingSchema.parse({ provider: 'salonic', handle: 'www' })).toBeUndefined() // reserved
+    expect(bookingSchema.parse({ provider: 'salonic', handle: '-bad' })).toBeUndefined() // bad DNS label
+    expect(
+      bookingSchema.parse({ provider: 'salonic', handle: 'https://evil.com/szalon' }),
+    ).toBeUndefined()
+    expect(
+      bookingSchema.parse({ provider: 'salonic', handle: 'javascript:alert(1)' }),
+    ).toBeUndefined()
+    expect(bookingSchema.parse({ provider: 'salonic', handle: 123 })).toBeUndefined()
+  })
+})
+
+describe('digitalConfigSchema — booking field', () => {
+  it('round-trips a valid booking', () => {
+    const parsed = digitalConfigSchema.parse({
+      ...baseConfig,
+      booking: { provider: 'salonic', handle: 'kiss-fodraszat' },
+    })
+    expect(parsed.booking).toEqual({ provider: 'salonic', handle: 'kiss-fodraszat' })
+  })
+
+  it('drops an invalid booking without failing the whole config save', () => {
+    const parsed = digitalConfigSchema.parse({
+      ...baseConfig,
+      booking: { provider: 'salonic', handle: 'https://evil.com/x' },
+    })
+    expect(parsed.booking).toBeUndefined()
+  })
+
+  it('is optional — a config without a booking parses fine', () => {
+    const parsed = digitalConfigSchema.parse(baseConfig)
+    expect(parsed.booking).toBeUndefined()
+  })
+})

package/src/controlChars.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { sanitizeHttpUrl, sanitizeText } from './index';
+
+/**
+ * The character classes in `stripUnsafeChars` and `sanitizeText` used to be
+ * written with LITERAL 0x00 / 0x1f / 0x7f bytes in the source.
+ *
+ * That was not a style problem. It made this file read as BINARY to ripgrep
+ * ("found \0 byte around offset 2873"), so `grep`/`Grep` silently skipped it
+ * and anyone searching for `sanitizeHttpUrl` concluded it did not exist. Worse,
+ * a Prettier run, an editor "strip control characters" save, or a
+ * `.gitattributes` filter would rewrite those classes without anyone noticing —
+ * and `sanitizeHttpUrl` is the SECOND-OPINION gate that `parseExternalUrl` in
+ * nfcard-api cross-checks itself against. The two disagreeing turns into a
+ * blanket refusal of every external URL: an outage, from a formatter.
+ *
+ * The bytes are now `\x00` / `\x1f` / `\x7f` escapes — same semantics, plain
+ * ASCII, greppable, formatter-proof. These tests keep it that way.
+ */
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SOURCE = fs.readFileSync(path.join(HERE, 'index.ts'));
+
+describe('the source file stays plain ASCII', () => {
+  it('contains NO literal control bytes — that is what made it read as binary', () => {
+    const offenders: string[] = [];
+    for (let i = 0; i < SOURCE.length; i++) {
+      const byte = SOURCE[i];
+      const isControl = byte === 0 || byte < 9 || (byte > 13 && byte < 32) || byte === 127;
+      if (isControl) offenders.push(`0x${byte.toString(16)} @ ${i}`);
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it('still declares the classes it always did, as escapes', () => {
+    const text = SOURCE.toString('utf8');
+    // ⚠️ Not a cosmetic assertion. `[ -<...]` — which is what these look like
+    // once the control bytes are eaten — is a RANGE over U+0020–U+003C that
+    // swallows `.` `/` `:` and every digit. That exact bug is on the record in
+    // this codebase; this pins the intended form so it cannot come back.
+    expect(text).toContain('/[\\x00-\\x1f\\x7f<>"\'`\\\\]/g');
+    expect(text).toContain('/[\\x00-\\x1f\\x7f]/g');
+  });
+});
+
+describe('the classes behave exactly as before the escape rewrite', () => {
+  const CONTROLS = ['\x00', '\x01', '\x1f', '\x7f'];
+
+  it.each(CONTROLS)('sanitizeHttpUrl strips %j out of a host', (ch) => {
+    expect(sanitizeHttpUrl(`https://exam${ch}ple.com/x`)).toBe('https://example.com/x');
+  });
+
+  it.each(CONTROLS)('sanitizeText strips %j', (ch) => {
+    expect(sanitizeText(`Ri${ch}csi`)).toBe('Ricsi');
+  });
+
+  it('still strips the HTML-ish characters beside them', () => {
+    expect(sanitizeHttpUrl('https://example.com/<script>')).toBe('https://example.com/script');
+  });
+
+  it('does NOT strip the printable characters a URL needs', () => {
+    // The guard against re-introducing the U+0020–U+003C range bug: every one
+    // of these sits inside that range and must survive.
+    expect(sanitizeHttpUrl('https://example.com/a.b/c-1?d=2&e=3')).toBe(
+      'https://example.com/a.b/c-1?d=2&e=3',
+    );
+  });
+});

package/src/tipJar.test.ts

@@ -1,77 +1,77 @@
-import { describe, expect, it } from 'vitest'
-import { tipJarSchema, digitalConfigSchema } from './index'
-
-const baseConfig = {
-  templateId: 'classic' as const,
-  accentColor: '#123456',
-  fontKey: 'inter',
-  showAvatar: true,
-}
-
-describe('tipJarSchema', () => {
-  it('accepts a valid provider + handle and stores only { provider, handle }', () => {
-    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'ricsi' })).toEqual({
-      provider: 'kofi',
-      handle: 'ricsi',
-    })
-  })
-
-  it('normalizes a pasted full URL down to the handle', () => {
-    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'https://ko-fi.com/ricsi?x=1' })).toEqual(
-      { provider: 'kofi', handle: 'ricsi' },
-    )
-  })
-
-  it('lowercases revolut handles', () => {
-    expect(tipJarSchema.parse({ provider: 'revolut', handle: 'RicSi' })).toEqual({
-      provider: 'revolut',
-      handle: 'ricsi',
-    })
-  })
-
-  it('keeps a sanitized custom label, capped at 40 chars', () => {
-    const out = tipJarSchema.parse({
-      provider: 'kofi',
-      handle: 'ricsi',
-      label: '<b>Támogass</b> ' + 'x'.repeat(60),
-    })
-    expect(out?.provider).toBe('kofi')
-    expect(out?.label).not.toContain('<')
-    expect((out?.label ?? '').length).toBeLessThanOrEqual(40)
-  })
-
-  it('drops everything invalid to undefined instead of throwing (never 400)', () => {
-    expect(tipJarSchema.parse(undefined)).toBeUndefined()
-    expect(tipJarSchema.parse(null)).toBeUndefined()
-    expect(tipJarSchema.parse('nonsense')).toBeUndefined()
-    expect(tipJarSchema.parse({})).toBeUndefined()
-    expect(tipJarSchema.parse({ provider: 'stripe', handle: 'ricsi' })).toBeUndefined()
-    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'x' })).toBeUndefined() // too short
-    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'https://evil.com/ricsi' })).toBeUndefined()
-    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'javascript:alert(1)' })).toBeUndefined()
-    expect(tipJarSchema.parse({ provider: 'kofi', handle: 123 })).toBeUndefined()
-  })
-})
-
-describe('digitalConfigSchema — tipJar field', () => {
-  it('round-trips a valid tipJar', () => {
-    const parsed = digitalConfigSchema.parse({
-      ...baseConfig,
-      tipJar: { provider: 'revolut', handle: 'ricsi' },
-    })
-    expect(parsed.tipJar).toEqual({ provider: 'revolut', handle: 'ricsi' })
-  })
-
-  it('drops an invalid tipJar without failing the whole config save', () => {
-    const parsed = digitalConfigSchema.parse({
-      ...baseConfig,
-      tipJar: { provider: 'kofi', handle: 'https://evil.com/x' },
-    })
-    expect(parsed.tipJar).toBeUndefined()
-  })
-
-  it('is optional — a config without a tipJar parses fine', () => {
-    const parsed = digitalConfigSchema.parse(baseConfig)
-    expect(parsed.tipJar).toBeUndefined()
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { tipJarSchema, digitalConfigSchema } from './index'
+
+const baseConfig = {
+  templateId: 'classic' as const,
+  accentColor: '#123456',
+  fontKey: 'inter',
+  showAvatar: true,
+}
+
+describe('tipJarSchema', () => {
+  it('accepts a valid provider + handle and stores only { provider, handle }', () => {
+    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'ricsi' })).toEqual({
+      provider: 'kofi',
+      handle: 'ricsi',
+    })
+  })
+
+  it('normalizes a pasted full URL down to the handle', () => {
+    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'https://ko-fi.com/ricsi?x=1' })).toEqual(
+      { provider: 'kofi', handle: 'ricsi' },
+    )
+  })
+
+  it('lowercases revolut handles', () => {
+    expect(tipJarSchema.parse({ provider: 'revolut', handle: 'RicSi' })).toEqual({
+      provider: 'revolut',
+      handle: 'ricsi',
+    })
+  })
+
+  it('keeps a sanitized custom label, capped at 40 chars', () => {
+    const out = tipJarSchema.parse({
+      provider: 'kofi',
+      handle: 'ricsi',
+      label: '<b>Támogass</b> ' + 'x'.repeat(60),
+    })
+    expect(out?.provider).toBe('kofi')
+    expect(out?.label).not.toContain('<')
+    expect((out?.label ?? '').length).toBeLessThanOrEqual(40)
+  })
+
+  it('drops everything invalid to undefined instead of throwing (never 400)', () => {
+    expect(tipJarSchema.parse(undefined)).toBeUndefined()
+    expect(tipJarSchema.parse(null)).toBeUndefined()
+    expect(tipJarSchema.parse('nonsense')).toBeUndefined()
+    expect(tipJarSchema.parse({})).toBeUndefined()
+    expect(tipJarSchema.parse({ provider: 'stripe', handle: 'ricsi' })).toBeUndefined()
+    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'x' })).toBeUndefined() // too short
+    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'https://evil.com/ricsi' })).toBeUndefined()
+    expect(tipJarSchema.parse({ provider: 'kofi', handle: 'javascript:alert(1)' })).toBeUndefined()
+    expect(tipJarSchema.parse({ provider: 'kofi', handle: 123 })).toBeUndefined()
+  })
+})
+
+describe('digitalConfigSchema — tipJar field', () => {
+  it('round-trips a valid tipJar', () => {
+    const parsed = digitalConfigSchema.parse({
+      ...baseConfig,
+      tipJar: { provider: 'revolut', handle: 'ricsi' },
+    })
+    expect(parsed.tipJar).toEqual({ provider: 'revolut', handle: 'ricsi' })
+  })
+
+  it('drops an invalid tipJar without failing the whole config save', () => {
+    const parsed = digitalConfigSchema.parse({
+      ...baseConfig,
+      tipJar: { provider: 'kofi', handle: 'https://evil.com/x' },
+    })
+    expect(parsed.tipJar).toBeUndefined()
+  })
+
+  it('is optional — a config without a tipJar parses fine', () => {
+    const parsed = digitalConfigSchema.parse(baseConfig)
+    expect(parsed.tipJar).toBeUndefined()
+  })
+})