@squiz/dx-json-schema-lib 1.2.13-alpha.2 → 1.2.13-alpha.4

package/src/errors/SchemaValidationError.ts

@@ -1,8 +1,16 @@
 import { IOutputError } from 'better-ajv-errors';
 
 export class SchemaValidationError extends Error {
-  constructor(validationErrors: IOutputError[], error?: Error) {
-    super(`failed validation: ${validationErrors.map((e) => e.error).join(', ')}`);
+  constructor(validationErrors: IOutputError[] | string, error?: Error) {
+    let message: string;
+
+    if (typeof validationErrors != 'string') {
+      message = validationErrors.map((e) => e.error).join(', ');
+    } else {
+      message = validationErrors;
+    }
+
+    super(`failed validation: ${message}`);
     this.stack = error?.stack;
     this.name = 'SchemaValidationError';
   }

package/src/formatted-text/v1/formattedText.json

@@ -1,7 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "array",
-  "additionalProperties": false,
   "title": "FormattedText",
 
   "items": {
@@ -27,6 +26,7 @@
     "TextNode": {
       "type": "object",
       "additionalProperties": false,
+
       "properties": {
         "type": { "const": "text" },
         "value": { "type": "string" }
@@ -34,112 +34,88 @@
       "required": ["type", "value"]
     },
 
-    "FormattedNode": {
+    "FormattingOptions": {
       "type": "object",
+
       "properties": {
-        "type": { "type": "string" },
-        "formattingOptions": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "alignment": {
-              "type": "string",
-              "enum": ["center", "left", "right", "justify"]
-            }
-          }
+        "alignment": {
+          "type": "string",
+          "enum": ["center", "left", "right", "justify"]
         }
-      },
-      "required": ["type"],
+      }
+    },
 
-      "additionalProperties": false
+    "WithChildrenNode": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/FormattedNodes"
+      }
     },
 
-    "FormattedNodeWithChildren": {
+    "FormattedTextTag": {
       "type": "object",
       "additionalProperties": false,
-      "allOf": [
-        { "$ref": "#/definitions/FormattedNode" },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "children": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/FormattedNodes"
-              }
-            }
-          },
-          "required": ["children"]
-        }
-      ]
-    },
 
-    "FormattedTextTag": {
-      "allOf": [
-        { "$ref": "#/definitions/FormattedNodeWithChildren" },
-        {
+      "properties": {
+        "children": {
+          "$ref": "#/definitions/WithChildrenNode"
+        },
+        "formattingOptions": { "$ref": "#/definitions/FormattingOptions" },
+        "type": { "const": "tag" },
+        "tag": { "type": "string", "minLength": 1 },
+        "attributes": {
           "type": "object",
-          "additionalProperties": false,
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "font": {
+          "title": "FormattedNodeFontProperties",
+          "type": "object",
+
           "properties": {
-            "type": { "const": "tag" },
-            "tag": { "type": "string", "minLength": 1 },
-            "attributes": {
-              "type": "object",
-              "additionalProperties": { "type": "string" }
-            },
-            "font": {
-              "title": "FormattedNodeFontProperties",
-              "type": "object",
-              "additionalProperties": false,
-              "properties": {
-                "bold": { "type": "boolean" },
-                "underline": { "type": "boolean" },
-                "italics": { "type": "boolean" },
-                "color": { "type": "string" },
-                "size": { "type": "string" },
-                "fontFamily": { "type": "string" }
-              }
-            }
-          },
-          "required": ["type", "tag"]
+            "bold": { "type": "boolean" },
+            "underline": { "type": "boolean" },
+            "italics": { "type": "boolean" },
+            "color": { "type": "string" },
+            "size": { "type": "string" },
+            "fontFamily": { "type": "string" }
+          }
         }
-      ]
+      },
+      "required": ["type", "tag", "children"]
     },
 
     "FormattedTextLinkToMatrixAsset": {
-      "allOf": [
-        { "$ref": "#/definitions/FormattedNodeWithChildren" },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "type": { "const": "link-to-matrix-asset" },
-            "matrixIdentifier": { "type": "string", "minLength": 1 },
-            "matrixDomain": { "type": "string", "minLength": 1 },
-            "matrixAssetId": { "type": "string", "minLength": 1 },
-            "target": { "type": "string", "enum": ["_blank", "_self", "_parent", "_top"] }
-          },
-          "required": ["type", "matrixDomain", "matrixAssetId", "target"]
-        }
-      ]
+      "type": "object",
+      "additionalProperties": false,
+
+      "properties": {
+        "children": {
+          "$ref": "#/definitions/WithChildrenNode"
+        },
+        "formattingOptions": { "$ref": "#/definitions/FormattingOptions" },
+        "type": { "const": "link-to-matrix-asset" },
+        "matrixIdentifier": { "type": "string", "minLength": 1 },
+        "matrixDomain": { "type": "string", "minLength": 1 },
+        "matrixAssetId": { "type": "string", "minLength": 1 },
+        "target": { "type": "string", "enum": ["_blank", "_self", "_parent", "_top"] }
+      },
+      "required": ["type", "matrixDomain", "matrixAssetId", "target", "children"]
     },
 
     "FormattedTextMatrixImage": {
-      "allOf": [
-        { "$ref": "#/definitions/FormattedNode" },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "type": { "const": "matrix-image" },
-            "matrixIdentifier": { "type": "string", "minLength": 1 },
-            "matrixDomain": { "type": "string", "minLength": 1 },
-            "matrixAssetId": { "type": "string", "minLength": 1 }
-          },
-          "required": ["type", "matrixDomain", "matrixAssetId"]
-        }
-      ]
+      "type": "object",
+      "additionalProperties": false,
+
+      "properties": {
+        "type": { "const": "matrix-image" },
+        "matrixIdentifier": { "type": "string", "minLength": 1 },
+        "matrixDomain": { "type": "string", "minLength": 1 },
+        "matrixAssetId": { "type": "string", "minLength": 1 },
+        "formattingOptions": { "$ref": "#/definitions/FormattingOptions" }
+      },
+      "required": ["type", "matrixDomain", "matrixAssetId"]
     }
   }
 }

package/src/formatted-text/v1/formattedText.ts

@@ -7,38 +7,39 @@
 
 export type FormattedNodes = HigherOrderFormattedNodes | BaseFormattedNodes;
 export type HigherOrderFormattedNodes = FormattedTextLinkToMatrixAsset | FormattedTextMatrixImage;
-export type FormattedTextLinkToMatrixAsset = FormattedNodeWithChildren & {
+export type WithChildrenNode = FormattedNodes[];
+export type BaseFormattedNodes = FormattedTextTag | TextNode;
+export type FormattedText = FormattedNodes[];
+
+export interface FormattedTextLinkToMatrixAsset {
+  children: WithChildrenNode;
+  formattingOptions?: FormattingOptions;
   type: 'link-to-matrix-asset';
   matrixIdentifier?: string;
   matrixDomain: string;
   matrixAssetId: string;
   target: '_blank' | '_self' | '_parent' | '_top';
-};
-export type FormattedNodeWithChildren = FormattedNode & {
-  children: FormattedNodes[];
-};
-export type FormattedTextMatrixImage = FormattedNode & {
+}
+export interface FormattingOptions {
+  alignment?: 'center' | 'left' | 'right' | 'justify';
+  [k: string]: unknown;
+}
+export interface FormattedTextMatrixImage {
   type: 'matrix-image';
   matrixIdentifier?: string;
   matrixDomain: string;
   matrixAssetId: string;
-};
-export type BaseFormattedNodes = FormattedTextTag | TextNode;
-export type FormattedTextTag = FormattedNodeWithChildren & {
+  formattingOptions?: FormattingOptions;
+}
+export interface FormattedTextTag {
+  children: WithChildrenNode;
+  formattingOptions?: FormattingOptions;
   type: 'tag';
   tag: string;
   attributes?: {
     [k: string]: string;
   };
   font?: FormattedNodeFontProperties;
-};
-export type FormattedText = FormattedNodes[];
-
-export interface FormattedNode {
-  type: string;
-  formattingOptions?: {
-    alignment?: 'center' | 'left' | 'right' | 'justify';
-  };
 }
 export interface FormattedNodeFontProperties {
   bold?: boolean;
@@ -47,6 +48,7 @@ export interface FormattedNodeFontProperties {
   color?: string;
   size?: string;
   fontFamily?: string;
+  [k: string]: unknown;
 }
 export interface TextNode {
   type: 'text';

package/src/formatted-text/v1/higherOrderFormattedTextToBaseFormattedText.spec.ts

@@ -0,0 +1,58 @@
+import { FormattedNodes, HigherOrderFormattedNodes } from './formattedText';
+import {
+  HigherOrderFormattedNodesMap,
+  higherOrderFormattedTextToBaseFormattedText,
+} from './higherOrderFormattedTextToBaseFormattedText';
+
+describe('higherOrderFormattedTextToBaseFormattedText', () => {
+  const mockResolvers: HigherOrderFormattedNodesMap = {
+    'link-to-matrix-asset': jest.fn((node: HigherOrderFormattedNodes) => {
+      return Promise.resolve({ type: 'text', value: `Link to asset ${node.matrixAssetId}` });
+    }),
+    'matrix-image': jest.fn((node: HigherOrderFormattedNodes) => {
+      return Promise.resolve({ type: 'text', value: `Image ${node.matrixAssetId}` });
+    }),
+  };
+
+  const testFormattedNodes: FormattedNodes = {
+    tag: 'p',
+    type: 'tag',
+    children: [
+      { type: 'text', value: 'This is some ' },
+      {
+        type: 'link-to-matrix-asset',
+        matrixIdentifier: 'abc123',
+        matrixDomain: 'example.com',
+        matrixAssetId: '12345',
+        target: '_blank',
+        children: [{ type: 'text', value: 'linked text' }],
+      },
+      { type: 'text', value: ' with an image ' },
+      {
+        type: 'matrix-image',
+        matrixIdentifier: 'abc123',
+        matrixDomain: 'example.com',
+        matrixAssetId: '54321',
+      },
+      { type: 'text', value: '.' },
+    ],
+  };
+
+  const expectedFormattedNodes: FormattedNodes = {
+    tag: 'p',
+    type: 'tag',
+    children: [
+      { type: 'text', value: 'This is some ' },
+      { type: 'text', value: 'Link to asset 12345' },
+      { type: 'text', value: ' with an image ' },
+      { type: 'text', value: 'Image 54321' },
+      { type: 'text', value: '.' },
+    ],
+  };
+
+  it('should replace higher order nodes with their resolved counterparts', async () => {
+    const result = await higherOrderFormattedTextToBaseFormattedText(testFormattedNodes, mockResolvers);
+
+    expect(result).toEqual(expectedFormattedNodes);
+  });
+});

package/src/formatted-text/v1/higherOrderFormattedTextToBaseFormattedText.ts

@@ -0,0 +1,36 @@
+import { BaseFormattedNodes, FormattedNodes, HigherOrderFormattedNodes } from './formattedText';
+
+export interface FormattedNodeWithChildren {
+  children: FormattedNodes[];
+}
+
+export type HigherOrderFormattedNodesMap = {
+  [key in HigherOrderFormattedNodes['type']]: (node: HigherOrderFormattedNodes) => Promise<BaseFormattedNodes>;
+};
+
+export async function higherOrderFormattedTextToBaseFormattedText(
+  node: FormattedNodes,
+  resolvers: HigherOrderFormattedNodesMap,
+): Promise<FormattedNodes> {
+  if (node.type in resolvers && nodeIsHigherOrder(node)) {
+    return await resolvers[node.type](node);
+  }
+
+  if (hasChildren(node)) {
+    const updatedChildren = await Promise.all(
+      node.children.map((child) => higherOrderFormattedTextToBaseFormattedText(child, resolvers)),
+    );
+
+    return { ...node, children: updatedChildren };
+  }
+
+  return node;
+}
+
+function hasChildren(node: any): node is FormattedNodeWithChildren {
+  return node && typeof node == 'object' && 'children' in node && Array.isArray(node.children);
+}
+
+function nodeIsHigherOrder(node: FormattedNodes): node is HigherOrderFormattedNodes {
+  return node.type === 'link-to-matrix-asset' || node.type === 'matrix-image';
+}

package/src/index.ts

@@ -3,6 +3,7 @@ export * as MANIFEST_SCHEMAS from './manifest/v1/manifestSchemas';
 
 export * as FORMATTED_TEXT_MODELS from './formatted-text/v1/formattedTextModels';
 export * as FORMATTED_TEXT_SCHEMAS from './formatted-text/v1/formattedTextSchemas';
+export * from './formatted-text/v1/higherOrderFormattedTextToBaseFormattedText';
 
 export * as SUB_SCHEMAS from './manifest/v1/subSchemas';
 

package/src/manifest/v1/Draft-07.json

@@ -0,0 +1,155 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "http://json-schema.org/draft-07/schema#",
+  "title": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#" }
+    },
+    "nonNegativeInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "nonNegativeIntegerDefault0": {
+      "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": { "type": "string" },
+      "uniqueItems": true,
+      "default": []
+    }
+  },
+  "type": ["object", "boolean"],
+  "properties": {
+    "$id": {
+      "type": "string",
+      "format": "uri-reference"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$ref": {
+      "type": "string",
+      "format": "uri-reference"
+    },
+    "$comment": {
+      "type": "string"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": true,
+    "readOnly": {
+      "type": "boolean",
+      "default": false
+    },
+    "writeOnly": {
+      "type": "boolean",
+      "default": false
+    },
+    "examples": {
+      "type": "array",
+      "items": true
+    },
+    "multipleOf": {
+      "type": "number",
+      "exclusiveMinimum": 0
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "number"
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "number"
+    },
+    "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+    "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": { "$ref": "#" },
+    "items": {
+      "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/schemaArray" }],
+      "default": true
+    },
+    "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+    "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "contains": { "$ref": "#" },
+    "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+    "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+    "required": { "$ref": "#/definitions/stringArray" },
+    "additionalProperties": { "$ref": "#" },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#" },
+      "propertyNames": { "format": "regex" },
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/stringArray" }]
+      }
+    },
+    "propertyNames": { "$ref": "#" },
+    "const": true,
+    "enum": {
+      "type": "array",
+      "items": true,
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        { "$ref": "#/definitions/simpleTypes" },
+        {
+          "type": "array",
+          "items": { "$ref": "#/definitions/simpleTypes" },
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "format": { "type": "string" },
+    "contentMediaType": { "type": "string" },
+    "contentEncoding": { "type": "string" },
+    "if": { "$ref": "#" },
+    "then": { "$ref": "#" },
+    "else": { "$ref": "#" },
+    "allOf": { "$ref": "#/definitions/schemaArray" },
+    "anyOf": { "$ref": "#/definitions/schemaArray" },
+    "oneOf": { "$ref": "#/definitions/schemaArray" },
+    "not": { "$ref": "#" }
+  },
+  "default": true
+}

package/src/manifest/v1/DxComponentInputSchema.json

@@ -4,17 +4,20 @@
   "title": "DxComponentInputSchema",
   "description": "Input schema for a DxComponent",
   "type": "object",
-  "properties": {
-    "type": {
-      "const": "object"
-    },
-    "additionalProperties": {
-      "default": false
-    }
-  },
   "allOf": [
     {
       "$ref": "DxContentMetaSchema.json"
+    },
+    {
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "object"
+        },
+        "additionalProperties": {
+          "default": false
+        }
+      }
     }
   ]
 }