@squiz/dx-json-schema-lib 1.34.1-alpha.1 → 1.34.1-alpha.3

package/lib/pageContents/v1/pageContents.json

@@ -0,0 +1,127 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "rule": {
+            "$ref": "#/definitions/rule"
+        },
+        "containers": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "layout": {
+                        "$ref": "#/definitions/layout"
+                    },
+                    "rule": {
+                        "$ref": "#/definitions/rule"
+                    },
+                    "items": {
+                        "$ref": "#/definitions/items"
+                    }
+                }
+            },
+            "additionalProperties": false
+        }
+    },
+    "required": ["containers"],
+    "definitions": {
+        "rule": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "enum": ["language", "segment", "split"]
+                },
+                "values": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": ["type", "values"]
+        },
+        "layout": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "type": {
+                    "type": "string",
+                    "enum": ["inline", "external-reference"]
+                },
+                "value": {
+                    "type": "string"
+                }
+            },
+            "required": ["name", "type", "value"]
+        },
+        "items": {
+            "type": "array",
+            "items": {
+                "properties": {
+                    "rule": {
+                        "$ref": "#/definitions/rule"
+                    },
+                    "type": {
+                        "type": "string",
+                        "enum": ["component", "rich-text"]
+                    },
+                    "component": {
+                        "type": "string"
+                    },
+                    "layout-area": {
+                        "type": "number"
+                    },
+                    "content": {
+                        "oneOf": [
+                            {
+                                "type": "object",
+                                "patternProperties": {
+                                    "^.*$": {
+                                        "oneOf": [
+                                            {
+                                                "type": "object",
+                                                "properties": {
+                                                    "html": {
+                                                        "type": "array",
+                                                        "items": {
+                                                            "type": "object",
+                                                            "properties": {
+                                                                "tag": {
+                                                                    "type": "string"
+                                                                },
+                                                                "content": {
+                                                                    "type": "string"
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                },
+                                                "description": "NOTE : This is a temp object, will be a reference to FT schema",
+                                                "additionalProperties": false
+                                            },
+                                            {
+                                                "type": "string",
+                                                "additionalProperties": {
+                                                    "type": "string"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            },
+                            {
+                                "type": "string"
+                            }
+                        ]
+                    }
+                },
+                "required": ["type", "content", "layout_area"]
+            }
+        }
+    },
+    "additionalProperties": false
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dx-json-schema-lib",
-  "version": "1.34.1-alpha.1",
+  "version": "1.34.1-alpha.3",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
@@ -31,5 +31,5 @@
     "@squiz/json-schema-library": "7.4.7",
     "ts-brand": "0.0.2"
   },
-  "gitHead": "6acc4d221f09f711a477236765017a2f956730bb"
+  "gitHead": "c7360adacee0d77cdef12576f51a23fd228bc501"
 }

package/src/JsonValidationService.spec.ts

@@ -17,6 +17,7 @@ import { FormattedTextType, SquizImageType, SquizLinkType } from './primitiveTyp
 import { TypeResolverBuilder } from './jsonTypeResolution/TypeResolverBuilder';
 import { MatrixAssetUri } from './validators/utils/matrixAssetValidator';
 import { MatrixAssetType } from './resolvableTypes';
+import { PageContents } from './pageContents/v1/pageContents';
 
 function expectToThrowErrorMatchingTypeAndMessage(
   // eslint-disable-next-line @typescript-eslint/ban-types
@@ -339,6 +340,101 @@ describe('JsonValidationService', () => {
       expect(jsonValidationService.validateRenderInput(schema, otherValue)).toEqual(true);
     });
   });
+
+  describe('validatePageContents', () => {
+    const validPageContents: PageContents[] = [
+      {
+        containers: [],
+      },
+      {
+        containers: [
+          {
+            layout: {
+              name: 'chris-custom-2-col-layout',
+              type: 'inline',
+              value: '<div>[area://output/1]</div>',
+            },
+            items: [
+              {
+                type: 'component',
+                content: 'content-store://asdfkjashdfkjhwek234j234',
+                component: 'namespace/componentname/version',
+                layout_area: 1,
+              },
+            ],
+          },
+        ],
+      },
+    ];
+    it.each(validPageContents)('should validate valid page contents', (input) => {
+      expect(jsonValidationService.validatePageContents(input)).toEqual(true);
+    });
+
+    it('should throw error for empty page contents', () => {
+      const input = {};
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validatePageContents(input);
+        },
+        SchemaValidationError,
+        'failed validation: The required property `containers` is missing at `#`',
+        {
+          '#': [
+            {
+              data: { key: 'containers', pointer: '#' },
+              message: 'The required property `containers` is missing at `#`',
+            },
+          ],
+        },
+      );
+    });
+
+    it('should throw error for invalid page contents with multiple errors', () => {
+      const input = {
+        containers: [
+          {
+            layout: {
+              name: 'chris-custom-2-col-layout',
+              type: 'inline',
+              value: 123,
+            },
+            items: [
+              {
+                type: 'bad-type',
+                content: 'content-store://asdfkjashdfkjhwek234j234',
+                component: 'namespace/componentname/version',
+                layout_area: 1,
+              },
+            ],
+          },
+        ],
+      };
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validatePageContents(input);
+        },
+        SchemaValidationError,
+        'failed validation: Expected `123` (number) in `#/containers/0/layout/value` to be of type `string`,' +
+          '\n' +
+          'Expected given value `bad-type` in #/containers/0/items/0/type` to be one of `[component, rich-text]`',
+        {
+          '#/containers/0/items/0/type': [
+            {
+              data: { pointer: '#/containers/0/items/0/type', value: 'bad-type', values: ['component', 'rich-text'] },
+              message:
+                'Expected given value `bad-type` in #/containers/0/items/0/type` to be one of `[component, rich-text]`',
+            },
+          ],
+          '#/containers/0/layout/value': [
+            {
+              data: { pointer: '#/containers/0/layout/value', expected: 'string', received: 'number', value: 123 },
+              message: 'Expected `123` (number) in `#/containers/0/layout/value` to be of type `string`',
+            },
+          ],
+        },
+      );
+    });
+  });
 });
 
 const defaultSchema: JSONSchema = {

package/src/JsonValidationService.ts

@@ -8,6 +8,7 @@ import MatrixAssetSchema from './manifest/v1/MatrixAssetSchema.json';
 import Draft07Schema from './manifest/v1/Draft-07.json';
 
 import FormattedText from './formatted-text/v1/formattedText.json';
+import PageContentsSchema from './pageContents/v1/pageContents.json';
 
 import v1 from './manifest/v1/v1.json';
 import { SchemaValidationError, ValidationData, ValidationDataMap } from './errors/SchemaValidationError';
@@ -162,6 +163,8 @@ export const RenderInputMetaSchema: MetaSchemaInput = {
   root: Draft07Schema,
 };
 
+export const PageContentsMetaSchema = new Draft07(PageContentsSchema, defaultConfig);
+
 export const ManifestV1MetaSchema: MetaSchemaInput = {
   root: v1,
   remotes: {
@@ -306,6 +309,10 @@ export class JsonValidationService {
 
     return processValidationResult(errors);
   }
+
+  validatePageContents(pageContents: JSONSchema) {
+    return processValidationResult(PageContentsMetaSchema.validate(pageContents));
+  }
 }
 
 function processValidationResult(errors: JSONError[]): true {

package/src/index.ts

@@ -1,6 +1,9 @@
 export * as MANIFEST_MODELS from './manifest/v1/manifestModels';
 export * as MANIFEST_SCHEMAS from './manifest/v1/manifestSchemas';
 
+export * as PAGE_CONTENTS_MODELS from './manifest/v1/manifestModels';
+export * as PAGE_CONTENT_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/resolveFormattedTextNodes';

package/src/pageContents/pageContentsModels.ts

@@ -0,0 +1 @@
+export * as v1 from './v1/pageContents';

package/src/pageContents/pageContentsSchemas.ts

@@ -0,0 +1,3 @@
+import v1 from './v1/pageContents.json';
+
+export { v1 };

package/src/pageContents/v1/pageContents.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "rule": {
+      "$ref": "#/definitions/rule"
+    },
+    "containers": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "layout": {
+            "$ref": "#/definitions/layout"
+          },
+          "rule": {
+            "$ref": "#/definitions/rule"
+          },
+          "items": {
+            "$ref": "#/definitions/items"
+          }
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "required": ["containers"],
+  "definitions": {
+    "rule": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["language", "segment", "split"]
+        },
+        "values": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "required": ["type", "values"]
+    },
+    "layout": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "enum": ["inline", "external-reference"]
+        },
+        "value": {
+          "type": "string"
+        }
+      },
+      "required": ["name", "type", "value"]
+    },
+    "items": {
+      "type": "array",
+      "items": {
+        "properties": {
+          "rule": {
+            "$ref": "#/definitions/rule"
+          },
+          "type": {
+            "type": "string",
+            "enum": ["component", "rich-text"]
+          },
+          "component": {
+            "type": "string"
+          },
+          "layout-area": {
+            "type": "number"
+          },
+          "content": {
+            "oneOf": [
+              {
+                "type": "object",
+                "patternProperties": {
+                  "^.*$": {
+                    "oneOf": [
+                      {
+                        "type": "object",
+                        "properties": {
+                          "html": {
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "tag": {
+                                  "type": "string"
+                                },
+                                "content": {
+                                  "type": "string"
+                                }
+                              }
+                            }
+                          }
+                        },
+                        "description": "NOTE : This is a temp object, will be a reference to FT schema",
+                        "additionalProperties": false
+                      },
+                      {
+                        "type": "string",
+                        "additionalProperties": {
+                          "type": "string"
+                        }
+                      }
+                    ]
+                  }
+                }
+              },
+              {
+                "type": "string"
+              }
+            ]
+          }
+        },
+        "required": ["type", "content", "layout_area"]
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/src/pageContents/v1/pageContents.ts

@@ -0,0 +1,52 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+export type Items = {
+  rule?: Rule;
+  type: 'component' | 'rich-text';
+  component?: string;
+  'layout-area'?: number;
+  content:
+    | {
+        /**
+         * This interface was referenced by `undefined`'s JSON-Schema definition
+         * via the `patternProperty` "^.*$".
+         */
+        [k: string]:
+          | {
+              html?: {
+                tag?: string;
+                content?: string;
+                [k: string]: unknown;
+              }[];
+            }
+          | string;
+      }
+    | string;
+  [k: string]: unknown;
+}[];
+
+export interface PageContents {
+  rule?: Rule;
+  containers: {
+    layout?: Layout;
+    rule?: Rule;
+    items?: Items;
+    [k: string]: unknown;
+  }[];
+}
+export interface Rule {
+  type: 'language' | 'segment' | 'split';
+  values: string[];
+  [k: string]: unknown;
+}
+export interface Layout {
+  name: string;
+  type: 'inline' | 'external-reference';
+  value: string;
+  [k: string]: unknown;
+}