@dev-crew-berlin/enter-js-utils 0.98.12 → 0.99.1

package/dist/lib/tokens.test.js

@@ -0,0 +1,508 @@
+import { describe, it, expect, vi } from 'vitest';
+import jws from 'jws';
+import { encodeJWS, parseEmailHtmlToken, parseEmailViewToken, parseRegistrationToken, parseTrackingToken, parseUnsubscribeToken, readRegistrationToken, storeRegistrationToken, deleteRegistrationToken } from './tokens';
+const options = {
+  jwtSecret: 'test-secret',
+  instanceName: 'my-instance'
+};
+function sign(payload, expiresInSeconds) {
+  return encodeJWS(payload, options.jwtSecret, expiresInSeconds);
+}
+describe('encodeJWS', () => {
+  it('produces a signature verifiable with the same secret', () => {
+    const token = encodeJWS({
+      hello: 'world'
+    }, options.jwtSecret);
+    expect(jws.verify(token, 'HS256', options.jwtSecret)).toBe(true);
+  });
+  it('rejects verification with a different secret', () => {
+    const token = encodeJWS({
+      hello: 'world'
+    }, options.jwtSecret);
+    expect(jws.verify(token, 'HS256', 'wrong-secret')).toBe(false);
+  });
+  it('round-trips the payload unchanged', () => {
+    const token = encodeJWS({
+      foo: 'bar',
+      n: 1
+    }, options.jwtSecret);
+    const decoded = jws.decode(token);
+    expect(decoded?.payload).toEqual({
+      foo: 'bar',
+      n: 1
+    });
+  });
+  it('adds an exp claim expiresInSeconds in the future when provided', () => {
+    const before = Math.floor(Date.now() / 1000);
+    const token = encodeJWS({
+      foo: 'bar'
+    }, options.jwtSecret, 3600);
+    const decoded = jws.decode(token);
+    expect(decoded?.payload.exp).toBeGreaterThanOrEqual(before + 3600);
+    expect(decoded?.payload.exp).toBeLessThanOrEqual(before + 3601);
+  });
+  it('omits exp entirely when no expiry is given', () => {
+    const token = encodeJWS({
+      foo: 'bar'
+    }, options.jwtSecret);
+    const decoded = jws.decode(token);
+    expect(decoded?.payload.exp).toBeUndefined();
+  });
+});
+describe('parseRegistrationToken', () => {
+  function makeToken(overrides = {}, expiresInSeconds = 600) {
+    return sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      session_type: 'register',
+      flags: {},
+      ...overrides
+    }, expiresInSeconds);
+  }
+  it('parses a valid token', () => {
+    const result = parseRegistrationToken(makeToken(), options);
+    expect(result.success).toBe(true);
+  });
+  it('surfaces the attendee id', () => {
+    const result = parseRegistrationToken(makeToken(), options);
+    if (result.success) expect(result.data.attendeeId).toBe('att-1');
+  });
+  it('defaults session_type to "register" when absent', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      exp: Math.floor(Date.now() / 1000) + 600
+    });
+    const result = parseRegistrationToken(token, options);
+    if (result.success) expect(result.data.sessionType).toBe('register');
+  });
+  it('surfaces a custom session_type', () => {
+    const result = parseRegistrationToken(makeToken({
+      session_type: 'edit'
+    }), options);
+    if (result.success) expect(result.data.sessionType).toBe('edit');
+  });
+  it('surfaces flags', () => {
+    const result = parseRegistrationToken(makeToken({
+      flags: {
+        skipPayment: true
+      }
+    }), options);
+    if (result.success) expect(result.data.flags).toEqual({
+      skipPayment: true
+    });
+  });
+  it('defaults flags to an empty object when absent', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      exp: Math.floor(Date.now() / 1000) + 600
+    });
+    const result = parseRegistrationToken(token, options);
+    if (result.success) expect(result.data.flags).toEqual({});
+  });
+  it('surfaces the email name/mailing id when present', () => {
+    const result = parseRegistrationToken(makeToken({
+      email: {
+        name: 'welcome',
+        mailing_id: 'mailing-1'
+      }
+    }), options);
+    if (result.success) {
+      expect(result.data.email).toEqual({
+        name: 'welcome',
+        mailingId: 'mailing-1'
+      });
+    }
+  });
+  it('leaves email undefined when absent', () => {
+    const result = parseRegistrationToken(makeToken(), options);
+    if (result.success) expect(result.data.email).toBeUndefined();
+  });
+  it('marks a token past its exp claim as expired, not rejected', () => {
+    const result = parseRegistrationToken(makeToken({}, -600), options);
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data.isExpired).toBe(true);
+  });
+  it('marks a token before its exp claim as not expired', () => {
+    const result = parseRegistrationToken(makeToken({}, 600), options);
+    if (result.success) expect(result.data.isExpired).toBe(false);
+  });
+  it('rejects a missing token', () => {
+    const result = parseRegistrationToken(undefined, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_missing'
+    });
+  });
+  it('rejects a token signed with the wrong secret', () => {
+    const token = encodeJWS({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1'
+    }, 'a-different-secret', 600);
+    expect(parseRegistrationToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects a token for a different instance', () => {
+    const token = makeToken({
+      instance_name: 'other-instance'
+    });
+    expect(parseRegistrationToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects a token missing an exp claim', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1'
+    });
+    expect(parseRegistrationToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+});
+describe('parseTrackingToken', () => {
+  function makeToken(overrides = {}) {
+    return sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      target: 'https://example.com/home',
+      mailing_id: null,
+      ...overrides
+    });
+  }
+  it('parses a valid token', () => {
+    const result = parseTrackingToken(makeToken(), options);
+    expect(result.success).toBe(true);
+  });
+  it('surfaces the target url', () => {
+    const result = parseTrackingToken(makeToken(), options);
+    if (result.success) expect(result.data.target).toBe('https://example.com/home');
+  });
+  it('surfaces a null mailing id as null, not undefined', () => {
+    const result = parseTrackingToken(makeToken(), options);
+    if (result.success) expect(result.data.mailingId).toBeNull();
+  });
+  it('surfaces a string mailing id', () => {
+    const result = parseTrackingToken(makeToken({
+      mailing_id: 'mailing-1'
+    }), options);
+    if (result.success) expect(result.data.mailingId).toBe('mailing-1');
+  });
+  it('rejects a missing token', () => {
+    expect(parseTrackingToken(undefined, options)).toEqual({
+      success: false,
+      error: 'token_missing'
+    });
+  });
+  it('rejects a token for a different instance', () => {
+    const token = makeToken({
+      instance_name: 'other-instance'
+    });
+    expect(parseTrackingToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects a token missing a target', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      mailing_id: null
+    });
+    expect(parseTrackingToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects a mailing id that is neither a string nor null', () => {
+    const token = makeToken({
+      mailing_id: 42
+    });
+    expect(parseTrackingToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+});
+describe('parseUnsubscribeToken', () => {
+  function makeToken(overrides = {}) {
+    return sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      email_address: 'a@b.com',
+      ...overrides
+    });
+  }
+  it('parses a valid token', () => {
+    const result = parseUnsubscribeToken(makeToken(), options);
+    expect(result.success).toBe(true);
+  });
+  it('surfaces the email address', () => {
+    const result = parseUnsubscribeToken(makeToken(), options);
+    if (result.success) expect(result.data.emailAddress).toBe('a@b.com');
+  });
+  it('surfaces the attendee id and email name', () => {
+    const result = parseUnsubscribeToken(makeToken(), options);
+    if (result.success) {
+      expect(result.data.attendeeId).toBe('att-1');
+      expect(result.data.emailName).toBe('welcome');
+    }
+  });
+  it('accepts a token with no exp claim (permanent link)', () => {
+    const result = parseUnsubscribeToken(makeToken(), options);
+    expect(result.success).toBe(true);
+  });
+  it('rejects a missing token', () => {
+    expect(parseUnsubscribeToken(undefined, options)).toEqual({
+      success: false,
+      error: 'token_missing'
+    });
+  });
+  it('rejects a token for a different instance', () => {
+    const token = makeToken({
+      instance_name: 'other-instance'
+    });
+    expect(parseUnsubscribeToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects a token missing an email address', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome'
+    });
+    expect(parseUnsubscribeToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+});
+describe('parseEmailHtmlToken', () => {
+  function makeToken(overrides = {}, expiresInSeconds = 600) {
+    return sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      mailing_id: null,
+      ...overrides
+    }, expiresInSeconds);
+  }
+  it('parses a valid token', () => {
+    const result = parseEmailHtmlToken(makeToken(), options);
+    expect(result.success).toBe(true);
+  });
+  it('surfaces the attendee id and email name', () => {
+    const result = parseEmailHtmlToken(makeToken(), options);
+    if (result.success) {
+      expect(result.data.attendeeId).toBe('att-1');
+      expect(result.data.emailName).toBe('welcome');
+    }
+  });
+  it('surfaces the mailing id when present', () => {
+    const result = parseEmailHtmlToken(makeToken({
+      mailing_id: 'mailing-1'
+    }), options);
+    if (result.success) expect(result.data.mailingId).toBe('mailing-1');
+  });
+  it('rejects a missing token', () => {
+    expect(parseEmailHtmlToken(undefined, options)).toEqual({
+      success: false,
+      error: 'token_missing'
+    });
+  });
+  it('rejects a token missing an exp claim', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome'
+    });
+    expect(parseEmailHtmlToken(token, options)).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects an expired token', () => {
+    const token = makeToken({}, -600);
+    expect(parseEmailHtmlToken(token, options)).toEqual({
+      success: false,
+      error: 'token_expired'
+    });
+  });
+});
+describe('parseEmailViewToken', () => {
+  function makeToken(overrides = {}, expiresInSeconds = 600) {
+    return sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      mailing_id: null,
+      purpose: 'view',
+      ...overrides
+    }, expiresInSeconds);
+  }
+  it('parses a valid view-purpose token', () => {
+    const result = parseEmailViewToken(makeToken(), options);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.attendeeId).toBe('att-1');
+      expect(result.data.emailName).toBe('welcome');
+      expect(result.data.purpose).toBe('view');
+      expect(result.data.mailingId).toBeUndefined();
+    }
+  });
+  it('parses a render-purpose token', () => {
+    const result = parseEmailViewToken(makeToken({
+      purpose: 'render'
+    }), options);
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data.purpose).toBe('render');
+  });
+  it('rejects a missing token', () => {
+    const result = parseEmailViewToken(undefined, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_missing'
+    });
+  });
+  it('rejects a token signed with the wrong secret', () => {
+    const token = encodeJWS({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      purpose: 'view'
+    }, 'a-different-secret', 600);
+    const result = parseEmailViewToken(token, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects a token for a different instance', () => {
+    const token = makeToken({
+      instance_name: 'other-instance'
+    });
+    const result = parseEmailViewToken(token, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects an invalid purpose value', () => {
+    const token = makeToken({
+      purpose: 'delete'
+    });
+    const result = parseEmailViewToken(token, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+  it('rejects an expired token', () => {
+    const token = makeToken({}, -600);
+    const result = parseEmailViewToken(token, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_expired'
+    });
+  });
+  it('surfaces the mailing id when present', () => {
+    const token = makeToken({
+      mailing_id: 'mailing-1'
+    });
+    const result = parseEmailViewToken(token, options);
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data.mailingId).toBe('mailing-1');
+  });
+  it('a "render"-purpose token is never returned for a token missing purpose entirely', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1',
+      email_name: 'welcome',
+      exp: Math.floor(Date.now() / 1000) + 600
+    });
+    const result = parseEmailViewToken(token, options);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_invalid'
+    });
+  });
+});
+describe('registration token cookie helpers', () => {
+  const cookieOptions = {
+    instanceName: options.instanceName,
+    jwtSecret: options.jwtSecret
+  };
+  it('readRegistrationToken parses the token from the default cookie name', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1'
+    }, 600);
+    const getCookie = vi.fn(name => name === 'enter-frontend.registation-token' ? {
+      name,
+      value: token
+    } : undefined);
+    const result = readRegistrationToken(getCookie, cookieOptions);
+    expect(getCookie).toHaveBeenCalledWith('enter-frontend.registation-token');
+    expect(result.success).toBe(true);
+  });
+  it('readRegistrationToken respects a custom cookie name', () => {
+    const token = sign({
+      instance_name: options.instanceName,
+      attendee_id: 'att-1'
+    }, 600);
+    const getCookie = vi.fn(name => name === 'custom-cookie' ? {
+      name,
+      value: token
+    } : undefined);
+    const result = readRegistrationToken(getCookie, {
+      ...cookieOptions,
+      registrationTokenCookieName: 'custom-cookie'
+    });
+    expect(result.success).toBe(true);
+  });
+  it('readRegistrationToken fails when the cookie is absent', () => {
+    const getCookie = vi.fn(() => undefined);
+    const result = readRegistrationToken(getCookie, cookieOptions);
+    expect(result).toEqual({
+      success: false,
+      error: 'token_missing'
+    });
+  });
+  it('storeRegistrationToken sets the cookie with lax/root defaults', () => {
+    const setCookie = vi.fn();
+    storeRegistrationToken('a-token', setCookie);
+    expect(setCookie).toHaveBeenCalledWith('enter-frontend.registation-token', 'a-token', {
+      sameSite: 'lax',
+      path: '/'
+    });
+  });
+  it('storeRegistrationToken respects a custom cookie name', () => {
+    const setCookie = vi.fn();
+    storeRegistrationToken('a-token', setCookie, {
+      registrationTokenCookieName: 'custom-cookie'
+    });
+    expect(setCookie).toHaveBeenCalledWith('custom-cookie', 'a-token', expect.anything());
+  });
+  it('deleteRegistrationToken removes the default cookie name', () => {
+    const deleteCookie = vi.fn();
+    deleteRegistrationToken(deleteCookie);
+    expect(deleteCookie).toHaveBeenCalledWith('enter-frontend.registation-token');
+  });
+  it('deleteRegistrationToken respects a custom cookie name', () => {
+    const deleteCookie = vi.fn();
+    deleteRegistrationToken(deleteCookie, {
+      registrationTokenCookieName: 'custom-cookie'
+    });
+    expect(deleteCookie).toHaveBeenCalledWith('custom-cookie');
+  });
+});

package/dist/models/email-content.d.ts

@@ -0,0 +1,23 @@
+export type ContentValue = {
+    type: 'handlebars' | 'text';
+    content: string;
+};
+export type EmailContentBlock = {
+    key: string;
+    name: string;
+    sort_order: number;
+    value: ContentValue;
+};
+export type PublicEmailContent = {
+    subject: ContentValue;
+    to: ContentValue;
+    to_name: ContentValue;
+    from: ContentValue;
+    cc: ContentValue;
+    bcc: ContentValue;
+    reply: ContentValue;
+    pre: ContentValue;
+    pdf: ContentValue;
+    pdfname: ContentValue;
+    blocks: EmailContentBlock[];
+};

package/dist/models/email-content.js

@@ -0,0 +1 @@
+export {};

package/dist/models/index.d.ts

@@ -16,6 +16,7 @@ export type { FieldValue } from './field-value';
 export type { TextField, EmailField, NumberField, CheckboxField, ToggleField, RadioField, SelectField, Field, } from './field';
 export { Instance } from './instance';
 export type { InstanceJSON } from './instance';
+export type { ContentValue, EmailContentBlock, PublicEmailContent, } from './email-content';
 export type { Permission } from './permission';
 export type { User } from './user';
 export type { Variable } from './variable';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-crew-berlin/enter-js-utils",
-  "version": "0.98.12",
+  "version": "0.99.1",
   "description": "utils such as vaildation and other helpers to work with data from the enter app",
   "files": [
     "dist",
@@ -79,6 +79,7 @@
   "dependencies": {
     "cookie": "^1.0.1",
     "eventsource-parser": "^3.0.6",
+    "handlebars": "^4.7.9",
     "jws": "^4.0.0",
     "stable-hash": "^0.0.5",
     "styled-jsx": "^5.1.6",