@bisondesk/website-commons-sdk 1.0.36 → 1.0.38

package/src/types/mailing-list.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+
+const emailSchema = z.string().email().min(1).toLowerCase();
+
+export const Contact = z.object({
+  email: emailSchema,
+  status: z.enum(['unsubscribed', 'subscribed', 'pending']).optional(),
+  fields: z
+    .object({
+      Country: z.string().nullable().optional(),
+      PreferredLanguage: z.string().nullable().optional(),
+      FirstName: z.string().nullable().optional(),
+      LastName: z.string().nullable().optional(),
+    })
+    .transform((data) => {
+      const normalizedData = Object.fromEntries(
+        Object.entries(data).filter(([, value]) => value !== undefined)
+      );
+
+      return normalizedData;
+    }),
+  tags: z.record(z.string(), z.boolean()).optional(),
+});
+
+export type Contact = z.input<typeof Contact>;
+
+export const CheckUserIsSubscribedRequest = z.object({
+  email: emailSchema,
+});
+
+export type CheckUserIsSubscribedRequest = z.infer<typeof CheckUserIsSubscribedRequest>;
+
+export type ContactStatus = z.infer<typeof Contact.shape.status>;
+
+export type CheckUserIsSubscribedResponse = {
+  createdAt?: string;
+  status?: 'unsubscribed' | 'subscribed' | 'pending';
+};
+
+export type UpsertContactResponse = {
+  subscribed: boolean;
+};
+
+export const SubscribeContactRequest = z.object({
+  email: emailSchema,
+  language: z.string(),
+});
+
+export type SubscribeContactRequest = z.infer<typeof SubscribeContactRequest>;
+
+export type SubscribeContactResponse = {
+  subscribedAt: string;
+};

package/src/types/search.ts

@@ -102,6 +102,7 @@ export type TermAggregation<T = string> = {
   type: AggregationType.term;
   fieldType: FieldTypes;
   orderBy?: 'count' | 'field';
+  format?: NumberMeta;
 };
 
 export type Range =

package/src/types/user-searches.ts

@@ -18,7 +18,7 @@ const BaseUserSearch = z
 type BaseUserSearch = z.infer<typeof BaseUserSearch>;
 
 export const UserSearch = BaseUserSearch.extend({
-  id: z.uuidv7(),
+  id: z.string().uuid(),
   createdBy: z.string(),
   createdAt: z.string(),
 });

package/src/types/user.test.ts

@@ -0,0 +1,128 @@
+import { UserDetails, VatSchema, isValidVatForCountry } from './user.js';
+
+const companyVatSchema = UserDetails.shape.company;
+
+describe('VatSchema (standalone)', () => {
+  describe('valid', () => {
+    test.each([
+      { input: 'PT123', expected: 'PT123' },
+      { input: 'gb123', expected: 'GB123' },
+      { input: 'X', expected: 'X' },
+      { input: 'X', expected: 'X' },
+    ])('$input -> $expected', ({ input, expected }) => {
+      const result = VatSchema.safeParse(input);
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(expected);
+    });
+  });
+
+  test('empty string coerces to undefined', () => {
+    const result = VatSchema.safeParse('');
+    expect(result.success).toBe(true);
+    expect(result.data).toBeUndefined();
+  });
+});
+
+describe('isValidVatForCountry', () => {
+  test.each([
+    { vat: 'PT123', country: 'PT', expected: true },
+    { vat: 'DE123', country: 'DE', expected: true },
+    { vat: 'EL123', country: 'GR', expected: true },
+    { vat: 'IE1234567X', country: 'IE', expected: true },
+    { vat: 'GB123', country: 'GB', expected: true },
+    { vat: 'XI123456789', country: 'GB', expected: true },
+    { vat: 'CHE123456789', country: 'CH', expected: true },
+    { vat: 'NO123456789', country: 'NO', expected: true },
+    { vat: 'ANYTHING', country: 'US', expected: true },
+    { vat: '1234567890', country: 'UA', expected: true },
+    { vat: '123456789', country: 'BY', expected: true },
+    { vat: '123456789', country: 'RS', expected: true },
+    { vat: 'DE123', country: 'PT', expected: false },
+    { vat: 'GR123', country: 'GR', expected: false },
+    { vat: 'PT', country: 'PT', expected: false },
+    { vat: 'CH123', country: 'CH', expected: false },
+    { vat: 'XI', country: 'GB', expected: false },
+  ])('vat=$vat country=$country -> $expected', ({ vat, country, expected }) => {
+    expect(isValidVatForCountry({ vat, country })).toBe(expected);
+  });
+});
+
+describe('UserDetails (full schema)', () => {
+  const validBase = {
+    email: 'test@example.com',
+    company: { country: 'PT', vat: 'PT123456789' },
+    marketingChannels: [],
+  };
+
+  test('parses valid full payload', () => {
+    const result = UserDetails.safeParse(validBase);
+    expect(result.success).toBe(true);
+    expect(result.data?.email).toBe('test@example.com');
+    expect(result.data?.company.vat).toBe('PT123456789');
+  });
+
+  test('lowercases email', () => {
+    const result = UserDetails.safeParse({ ...validBase, email: 'TEST@EXAMPLE.COM' });
+    expect(result.success).toBe(true);
+    expect(result.data?.email).toBe('test@example.com');
+  });
+
+  test('company vat invalid does not affect other fields parsing', () => {
+    const result = UserDetails.safeParse({
+      ...validBase,
+      company: { country: 'PT', vat: 'DE123' },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('company without vat still valid', () => {
+    const result = UserDetails.safeParse({ ...validBase, company: { country: 'PT' } });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('UserDetails company vat (with country)', () => {
+  describe('valid', () => {
+    test.each([
+      { input: { country: 'PT', vat: 'PT123456789' } },
+      { input: { country: 'DE', vat: 'DE123' } },
+      { input: { country: 'gr', vat: 'el123' }, expectedVat: 'EL123' },
+      { input: { country: 'IE', vat: 'IE1234567X' } },
+      { input: { country: 'GB', vat: 'GB123456789' } },
+      { input: { country: 'GB', vat: 'XI123456789' } },
+      { input: { country: 'CH', vat: 'CHE123456789' } },
+      { input: { country: 'NO', vat: 'NO123456789' } },
+      { input: { country: 'US', vat: 'ANYTHING123' } },
+      { input: { country: 'UA', vat: '1234567890' } },
+      { input: { country: 'BY', vat: '123456789' } },
+      { input: { country: 'RS', vat: '123456789' } },
+      { input: { country: 'BR', vat: 'abc' }, expectedVat: 'ABC' },
+      { input: { vat: 'SOMETHING' } },
+      { input: { vat: '' } },
+      { input: {} },
+    ])('$input', ({ input, expectedVat }) => {
+      const result = companyVatSchema.safeParse(input);
+      expect(result.success).toBe(true);
+      if (expectedVat) {
+        expect(result.data?.vat).toBe(expectedVat);
+      }
+    });
+  });
+
+  describe('invalid', () => {
+    test.each([
+      { input: { country: 'PT', vat: 'DE123' } },
+      { input: { country: 'DE', vat: 'DE' } },
+      { input: { country: 'GR', vat: 'GR123' } },
+      { input: { country: 'CH', vat: 'CH123' } },
+      { input: { country: 'GB', vat: 'XI' } },
+    ])('$input', ({ input }) => {
+      const result = companyVatSchema.safeParse(input);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        const issue = result.error.issues[0];
+        expect((issue as any).params).toEqual({ messageKey: 'vat.invalidFormat' });
+      }
+    });
+  });
+});

package/src/types/user.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { MarketingChannel } from './index.js';
 
 export type AuthRequest = {
@@ -10,20 +11,113 @@ export enum FleetSize {
   Large = '6+',
 }
 
-export type UserDetails = {
-  firstName?: string;
-  lastName?: string;
-  phone?: string;
-  preferredLanguage?: string;
-  fleetSize?: FleetSize;
-  trader?: boolean;
-  email?: string;
-  company: {
-    country?: string;
-    city?: string | undefined;
-    name?: string | undefined;
-    vat?: string | undefined;
-    postalCode?: string | undefined;
-  };
-  marketingChannels: MarketingChannel[];
+export const VatSchema = z.string().toUpperCase();
+
+/**
+ * Light VAT-number validation patterns by country.
+ *
+ * Countries without an entry accept any VAT number (no validation).
+ *
+ * Includes EU-27, EEA non-EU (NO, IS), Switzerland (CH), and the UK (GB).
+ * Note: Liechtenstein shares the Swiss CHE VAT system and is intentionally
+ * excluded — its numbers don't start with "LI".
+ */
+const VAT_PATTERNS: Record<string, RegExp> = {
+  // EU-27
+  AT: /^AT.+/,
+  BE: /^BE.+/,
+  BG: /^BG.+/,
+  CY: /^CY.+/,
+  CZ: /^CZ.+/,
+  DE: /^DE.+/,
+  DK: /^DK.+/,
+  EE: /^EE.+/,
+  ES: /^ES.+/,
+  FI: /^FI.+/,
+  FR: /^FR.+/,
+  GR: /^EL.+/,
+  HR: /^HR.+/,
+  HU: /^HU.+/,
+  IE: /^IE.+/,
+  IT: /^IT.+/,
+  LT: /^LT.+/,
+  LU: /^LU.+/,
+  LV: /^LV.+/,
+  MT: /^MT.+/,
+  NL: /^NL.+/,
+  PL: /^PL.+/,
+  PT: /^PT.+/,
+  RO: /^RO.+/,
+  SE: /^SE.+/,
+  SI: /^SI.+/,
+  SK: /^SK.+/,
+  // EEA non-EU
+  NO: /^NO.+/,
+  IS: /^IS.+/,
+  // Switzerland — 3-letter CHE prefix
+  CH: /^CHE.+/,
+  // United Kingdom + Northern Ireland (XI prefix post-Brexit)
+  GB: /^(GB|XI).+/,
+};
+
+export const isValidVatForCountry = ({
+  vat,
+  country,
+}: {
+  vat: string;
+  country: string;
+}): boolean => {
+  const pattern = VAT_PATTERNS[country.toUpperCase()];
+  if (!pattern) {
+    return true;
+  }
+  return pattern.test(vat);
+};
+
+const getVatPrefix = (country: string): string => {
+  const pattern = VAT_PATTERNS[country.toUpperCase()];
+  if (!pattern) {
+    return '';
+  }
+  const match = pattern.toString().match(/\^(\w+)/);
+  return match ? match[1] : '';
 };
+
+export const UserDetails = z.object({
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  phone: z.string().optional(),
+  preferredLanguage: z.string().optional(),
+  fleetSize: z.nativeEnum(FleetSize).optional(),
+  trader: z.boolean().optional(),
+  email: z.string().email().toLowerCase(),
+  company: z
+    .object({
+      country: z.string().optional(),
+      city: z.string().optional(),
+      name: z.string().optional(),
+      vat: VatSchema.optional(),
+      postalCode: z.string().optional(),
+    })
+    /* TODO when updating to zod v4, change addIssue options to 
+    message: 'vat.invalidFormat',
+    path: ['vat'],
+  */
+    .superRefine((data, ctx) => {
+      if (!data.vat || !data.country) {
+        return;
+      }
+      if (!isValidVatForCountry({ vat: data.vat, country: data.country })) {
+        const prefix = getVatPrefix(data.country);
+
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['vat'],
+          params: { prefix, messageKey: 'vat.invalidFormat' },
+        });
+      }
+    }),
+  marketingChannels: z.array(z.nativeEnum(MarketingChannel)),
+});
+
+export type UserDetails = z.infer<typeof UserDetails>;