@squiz/dx-common-lib 1.2.11 → 1.2.13-alpha.0

package/src/formatted-text/formattedTextToHtmlSting.spec.ts

@@ -0,0 +1,235 @@
+import { FORMATTED_TEXT_MODELS } from '@squiz/dx-json-schema-lib';
+import { formattedTextToHtmlSting } from './formattedTextToHtmlSting';
+
+type FormattedNodes = FORMATTED_TEXT_MODELS.v1.FormattedNodes;
+type FormattedTextTag = FORMATTED_TEXT_MODELS.v1.FormattedTextTag;
+
+describe('formattedTextToHtmlSting', () => {
+  it('should convert text nodes to HTML', () => {
+    const textNode: FormattedNodes = {
+      type: 'text',
+      value: 'Hello, world!',
+    };
+    expect(formattedTextToHtmlSting(textNode)).toBe('Hello, world!');
+  });
+
+  it('should convert tag nodes to HTML', () => {
+    const tagNode: FormattedNodes = {
+      type: 'tag',
+      tag: 'p',
+      children: [{ type: 'text', value: 'Hello, world!' }],
+    };
+    expect(formattedTextToHtmlSting(tagNode)).toBe('<p>Hello, world!</p>');
+  });
+
+  it('should convert tag nodes with attributes to HTML', () => {
+    const tagNode: FormattedNodes = {
+      type: 'tag',
+      tag: 'p',
+      attributes: {
+        id: 'hello-world',
+        class: 'greeting',
+      },
+      children: [{ type: 'text', value: 'Hello, world!' }],
+    };
+    expect(formattedTextToHtmlSting(tagNode)).toBe('<p id="hello-world" class="greeting">Hello, world!</p>');
+  });
+
+  it('should convert tag nodes with font properties to HTML', () => {
+    const tagNode: FormattedNodes = {
+      type: 'tag',
+      tag: 'p',
+      font: {
+        bold: true,
+        underline: true,
+        italics: false,
+        color: 'red',
+        size: 'large',
+        fontFamily: 'Arial',
+      },
+      children: [{ type: 'text', value: 'Hello, world!' }],
+    };
+    expect(formattedTextToHtmlSting(tagNode)).toBe(
+      '<p class="bold underline color-red size-large font-Arial">Hello, world!</p>',
+    );
+  });
+
+  it('converts a tag node with attributes but no children to html', () => {
+    const node: FormattedNodes = {
+      type: 'tag',
+      tag: 'p',
+      children: [],
+      attributes: { class: 'test-class' },
+    };
+    expect(formattedTextToHtmlSting(node)).toEqual('<p class="test-class"></p>');
+  });
+
+  it('converts a tag node with children but no attributes to html', () => {
+    const node: FormattedNodes = {
+      type: 'tag',
+      tag: 'p',
+      children: [
+        { type: 'text', value: 'This is a test' },
+        { type: 'text', value: 'This is another test' },
+      ],
+    };
+    expect(formattedTextToHtmlSting(node)).toEqual('<p>This is a testThis is another test</p>');
+  });
+
+  it('converts a tag node with children and attributes to html', () => {
+    const node: FormattedNodes = {
+      type: 'tag',
+      tag: 'p',
+      attributes: { class: 'test-class' },
+      children: [
+        { type: 'text', value: 'This is a test' },
+        { type: 'text', value: 'This is another test' },
+      ],
+    };
+    expect(formattedTextToHtmlSting(node)).toEqual('<p class="test-class">This is a testThis is another test</p>');
+  });
+
+  it('should convert a tag node with attributes to HTML', () => {
+    const input: FormattedNodes = {
+      type: 'tag',
+      tag: 'div',
+      children: [],
+      attributes: {
+        id: 'my-div',
+        'data-foo': 'bar',
+      },
+    };
+    const expectedOutput = '<div id="my-div" data-foo="bar"></div>';
+    expect(formattedTextToHtmlSting(input)).toEqual(expectedOutput);
+  });
+
+  it('should add the correct class for left alignment', () => {
+    const formattedNode: FormattedTextTag = {
+      type: 'tag',
+      children: [],
+      tag: 'p',
+      formattingOptions: {
+        alignment: 'left',
+      },
+    };
+    const html = formattedTextToHtmlSting(formattedNode);
+    expect(html).toEqual('<p class="left"></p>');
+  });
+
+  it('should add the correct class for right alignment', () => {
+    const formattedNode: FormattedTextTag = {
+      type: 'tag',
+      children: [],
+      tag: 'p',
+      formattingOptions: {
+        alignment: 'right',
+      },
+    };
+    const html = formattedTextToHtmlSting(formattedNode);
+    expect(html).toEqual('<p class="right"></p>');
+  });
+
+  it('should add the correct class for center alignment', () => {
+    const formattedNode: FormattedTextTag = {
+      type: 'tag',
+      children: [],
+      tag: 'p',
+      formattingOptions: {
+        alignment: 'center',
+      },
+    };
+    const html = formattedTextToHtmlSting(formattedNode);
+    expect(html).toEqual('<p class="center"></p>');
+  });
+
+  it('should add the correct class for justify alignment', () => {
+    const formattedNode: FormattedTextTag = {
+      type: 'tag',
+      children: [],
+      tag: 'p',
+      formattingOptions: {
+        alignment: 'justify',
+      },
+    };
+    const html = formattedTextToHtmlSting(formattedNode);
+    expect(html).toEqual('<p class="justify"></p>');
+  });
+
+  it('should handle input with formattingOptions, font and class attributes', () => {
+    const formattedTextTag: FormattedTextTag = {
+      type: 'tag',
+      tag: 'p',
+      formattingOptions: {
+        alignment: 'center',
+      },
+      font: {
+        bold: true,
+        color: 'red',
+      },
+      attributes: {
+        class: 'my-class',
+      },
+      children: [
+        {
+          type: 'text',
+          value: 'Hello, World!',
+        },
+      ],
+    };
+
+    const expectedResult = '<p class="my-class bold color-red center">Hello, World!</p>';
+
+    const result = formattedTextToHtmlSting(formattedTextTag);
+    expect(result).toBe(expectedResult);
+  });
+
+  it('should return an error message for an unknown node type', () => {
+    const formattedNodes: FormattedNodes = {
+      type: 'unknown' as any,
+      value: 'Hello World!',
+    };
+    const expectedHTML = `<p class="invalid-node-type"> node of type "unknown" cannot be converted to html</p>`;
+    expect(formattedTextToHtmlSting(formattedNodes)).toEqual(expectedHTML);
+  });
+
+  it('should handle deeply nested FormattedNodes object', () => {
+    const formattedNodes: FormattedNodes = {
+      type: 'tag',
+      tag: 'div',
+      formattingOptions: {
+        alignment: 'justify',
+      },
+      children: [
+        {
+          type: 'text',
+          value: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ',
+        },
+        {
+          type: 'tag',
+          tag: 'strong',
+          font: {
+            bold: true,
+          },
+          children: [
+            {
+              type: 'text',
+              value: 'Vestibulum',
+            },
+            {
+              type: 'text',
+              value: ' dictum',
+            },
+          ],
+        },
+        {
+          type: 'text',
+          value: ' mi vel urna maximus, et luctus ipsum tincidunt',
+        },
+      ],
+    };
+
+    expect(formattedTextToHtmlSting(formattedNodes)).toMatchInlineSnapshot(
+      `"<div class=\\"justify\\">Lorem ipsum dolor sit amet, consectetur adipiscing elit. <strong class=\\"bold\\">Vestibulum dictum</strong> mi vel urna maximus, et luctus ipsum tincidunt</div>"`,
+    );
+  });
+});

package/src/formatted-text/formattedTextToHtmlSting.ts

@@ -0,0 +1,100 @@
+import { FORMATTED_TEXT_MODELS } from '@squiz/dx-json-schema-lib';
+
+type FormattedNodes = FORMATTED_TEXT_MODELS.v1.FormattedNodes;
+type FormattedTextTag = FORMATTED_TEXT_MODELS.v1.FormattedTextTag;
+type FormattedNodeFontProperties = FORMATTED_TEXT_MODELS.v1.FormattedNodeFontProperties;
+
+export function formattedTextToHtmlSting(formattedNodes: FormattedNodes): string {
+  switch (formattedNodes.type) {
+    case 'text':
+      return formattedNodes.value;
+    case 'tag':
+      return buildTagHTML(formattedNodes);
+    default:
+      return unknownNodeType(formattedNodes);
+  }
+}
+function buildTagHTML(formattedTextTag: FormattedTextTag): string {
+  const classes = getClassString(formattedTextTag);
+
+  if (!formattedTextTag.attributes) {
+    formattedTextTag.attributes = { class: classes };
+  } else {
+    formattedTextTag.attributes.class = classes;
+  }
+
+  const attributesStr = buildAttributesString(formattedTextTag.attributes);
+  const childrenHTML = buildChildrenHTML(formattedTextTag.children);
+
+  return `<${formattedTextTag.tag}${attributesStr}>${childrenHTML}</${formattedTextTag.tag}>`;
+}
+
+function buildChildrenHTML(children: FormattedNodes[] | undefined): string {
+  if (!children) {
+    return '';
+  }
+  return children.map(formattedTextToHtmlSting).join('');
+}
+
+function unknownNodeType(node: FormattedNodes): string {
+  return `<p class="invalid-node-type"> node of type "${node.type}" cannot be converted to html</p>`;
+}
+
+function getClassString(formattedTextTag: FormattedTextTag) {
+  const fontClasses = buildFontClasses(formattedTextTag.font);
+
+  let string = formattedTextTag?.attributes?.class ?? '';
+
+  if (formattedTextTag?.formattingOptions?.alignment) {
+    fontClasses.push(formattedTextTag.formattingOptions.alignment);
+  }
+
+  if (fontClasses.length > 0) {
+    string += ' ' + fontClasses.join(' ');
+  }
+
+  return string.trim();
+}
+
+function buildAttributesString(attributes: { [k: string]: string } | undefined): string {
+  if (!attributes) {
+    return '';
+  }
+
+  let attributesString = '';
+  for (const attribute in attributes) {
+    if (attributes[attribute] !== '') {
+      attributesString += ` ${attribute}="${attributes[attribute]}"`;
+    }
+  }
+
+  return attributesString;
+}
+
+function buildFontClasses(font: FormattedNodeFontProperties | undefined): string[] {
+  if (!font) {
+    return [];
+  }
+
+  const classes: string[] = [];
+  if (font.bold) {
+    classes.push('bold');
+  }
+  if (font.underline) {
+    classes.push('underline');
+  }
+  if (font.italics) {
+    classes.push('italics');
+  }
+  if (font.color) {
+    classes.push(`color-${font.color}`);
+  }
+  if (font.size) {
+    classes.push(`size-${font.size}`);
+  }
+  if (font.fontFamily) {
+    classes.push(`font-${font.fontFamily}`);
+  }
+
+  return classes;
+}

package/src/index.ts

@@ -4,3 +4,10 @@ export * from './util';
 export * from './zip/zipDirectory';
 export * from './server-utils/errorMiddleware';
 export * from './server-utils/requestLogger';
+export * from './api-key-validation/ApiKeyValidationService';
+export * from './api-key-validation/CloudflareApiKeyService';
+export * from './api-key-validation/DevelopmentApiKeyService';
+export * from './api-key-validation/getApiKeyService';
+export * from './server-utils/apiKeyMiddleware';
+export * from './cache';
+export * from './formatted-text/formattedTextToHtmlSting';

package/src/server-utils/apiKeyMiddleware.spec.ts

@@ -0,0 +1,50 @@
+import { UnAuthenticatedRequestError } from '../error/UnAuthenticatedRequestError';
+import { apiKeyMiddleware } from './apiKeyMiddleware';
+
+const keyIsValid = jest.fn().mockImplementation(() => true);
+const matrixKeyIsValid = jest.fn().mockImplementation(() => true);
+
+describe('apiKeyMiddleware', () => {
+  const middleware = apiKeyMiddleware({ keyIsValid, matrixKeyIsValid });
+
+  it('should return an express middleware which', () => {
+    expect(middleware).toBeInstanceOf(Function);
+  });
+
+  describe('middleware', () => {
+    it('should call next is key is invalid but matrix ke is valid', () => {
+      const nextFunc = jest.fn().mockImplementation(() => {
+        /* no op */
+      });
+      keyIsValid.mockImplementation(() => false);
+      keyIsValid.mockImplementation(() => true);
+
+      middleware({ header: () => 'some-key' } as any, {} as any, nextFunc);
+
+      expect(nextFunc).toHaveBeenCalled();
+    });
+
+    it('should call next if api key is valid', () => {
+      const nextFunc = jest.fn().mockImplementation(() => {
+        /* no op */
+      });
+
+      middleware({ header: () => 'some-key' } as any, {} as any, nextFunc);
+
+      expect(nextFunc).toHaveBeenCalled();
+    });
+
+    it('should throw an UnAuthenticatedRequestError if key is invalid', () => {
+      const nextFunc = jest.fn().mockImplementation(() => {
+        /* no op */
+      });
+
+      keyIsValid.mockImplementation(() => false);
+      matrixKeyIsValid.mockImplementation(() => false);
+
+      expect(() => middleware({ header: () => 'some-key' } as any, {} as any, nextFunc)).toThrowError(
+        new UnAuthenticatedRequestError(`API KEY IS INVALID`),
+      );
+    });
+  });
+});

package/src/server-utils/apiKeyMiddleware.ts

@@ -0,0 +1,23 @@
+import type { Request, Response } from 'express';
+import { ApiKeyValidationService } from '../api-key-validation/ApiKeyValidationService';
+import { UnAuthenticatedRequestError } from '../error/UnAuthenticatedRequestError';
+
+export function apiKeyMiddleware(
+  apiKeyService: ApiKeyValidationService,
+): (req: Request, res: Response, next: any) => void {
+  return function (req: Request, res: Response, next: any) {
+    const key = req.header('x-api-key');
+
+    if (req.path == '/health') {
+      next();
+      return;
+    }
+
+    if (apiKeyService.keyIsValid(key) || apiKeyService.matrixKeyIsValid(key)) {
+      next();
+      return;
+    }
+
+    throw new UnAuthenticatedRequestError(`API KEY IS INVALID`);
+  };
+}

package/tsconfig.json

@@ -9,7 +9,7 @@
     "sourceMap": true
   },
 
-  "references": [],
+  "references": [{ "path": "../dx-json-schema-lib" }],
 
   "include": ["src/**/*.ts", "src/**/*.json"],
   "exclude": ["jest.config.ts"]