@squiz/dx-json-schema-lib 1.2.13-alpha.0

package/src/manifest/v1/DxComponentInputSchema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "DxComponentInputSchema.json",
+  "title": "DxComponentInputSchema",
+  "description": "Input schema for a DxComponent",
+  "type": "object",
+  "properties": {
+    "type": {
+      "const": "object"
+    },
+    "additionalProperties": {
+      "default": false
+    }
+  },
+  "allOf": [
+    {
+      "$ref": "DxContentMetaSchema.json"
+    }
+  ]
+}

package/src/manifest/v1/DxComponentInputSchema.spec.ts

@@ -0,0 +1,136 @@
+import { JsonValidationService } from '../../JsonValidationService';
+
+describe('DxComponentInputSchema', () => {
+  let jsonValidationService: JsonValidationService;
+  beforeAll(() => {
+    jsonValidationService = new JsonValidationService();
+  });
+
+  it('should allow empty object', () => {
+    expect(() => jsonValidationService.validateContentSchema({})).not.toThrowError();
+  });
+
+  it('should require required if properties is specified', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        properties: {
+          foo: {
+            type: 'string',
+          },
+        },
+      }),
+    ).toThrowError();
+  });
+
+  it('should pass if required and properties are specified', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        required: ['foo'],
+        properties: {
+          foo: {
+            type: 'string',
+          },
+        },
+      }),
+    ).not.toThrowError();
+  });
+
+  it('should error if type is not "object"', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        type: 'string',
+      }),
+    ).toThrowError();
+  });
+
+  it('should allow a nested type to be "FormattedText"', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'FormattedText',
+          },
+        },
+        required: ['foo'],
+      }),
+    ).not.toThrowError();
+  });
+
+  it('should error on unknown keywords', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        type: 'object',
+        foo: 'bar',
+      }),
+    ).toThrowError();
+  });
+
+  it('should allow a nested property to be an array of of objects which have a property of type to be "FormattedText" that is required', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                bar: {
+                  type: 'FormattedText',
+                },
+              },
+              required: ['bar'],
+            },
+          },
+        },
+        required: ['foo'],
+      }),
+    ).not.toThrowError();
+  });
+
+  it('should error if any nested object does not have a required property', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                bar: {
+                  type: 'FormattedText',
+                },
+              },
+            },
+          },
+        },
+        required: ['foo'],
+      }),
+    ).toThrowError();
+  });
+
+  it('should succeed if required is on every nested object', () => {
+    expect(() =>
+      jsonValidationService.validateContentSchema({
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                bar: {
+                  type: 'FormattedText',
+                },
+              },
+              required: ['bar'],
+            },
+          },
+        },
+        required: ['foo'],
+      }),
+    ).not.toThrowError();
+  });
+});

package/src/manifest/v1/DxContentMetaSchema.json

@@ -0,0 +1,165 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "DxContentMetaSchema.json",
+  "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", "FormattedText"]
+    },
+    "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": "#" }
+  },
+  "additionalProperties": false,
+  "dependencies": {
+    "properties": {
+      "properties": {
+        "required": {
+          "$ref": "#/definitions/stringArray"
+        }
+      },
+      "required": ["required"]
+    }
+  }
+}

package/src/manifest/v1/__test__/schemas/badFunctionInputComponent.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "../../v1.json",
+  "description": "t",
+  "displayName": "t",
+  "name": "test",
+  "namespace": "other",
+  "mainFunction": "main",
+  "version": "1.0.4",
+  "environment": [],
+  "functions": [
+    {
+      "entry": "main.js",
+      "name": "main",
+      "output": {
+        "responseType": "html"
+      },
+      "input": {
+        "type": "object",
+        "properties": {
+          "textValue": {
+            "type": "badInputType"
+          },
+          "anotherValue": {
+            "type": "object",
+            "properties": {
+              "xt": {
+                "type": "FormattedText"
+              }
+            },
+            "additionalProperties": {
+              "type": "FormattedText"
+            }
+          }
+        },
+        "required": []
+      }
+    }
+  ]
+}

package/src/manifest/v1/__test__/schemas/badNestedFunctionInput.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "../../v1.json",
+  "description": "t",
+  "displayName": "t",
+  "name": "test",
+  "namespace": "other",
+  "mainFunction": "main",
+  "version": "1.0.4",
+  "environment": [],
+  "functions": [
+    {
+      "entry": "main.js",
+      "name": "main",
+      "output": {
+        "responseType": "html"
+      },
+      "input": {
+        "type": "object",
+        "properties": {
+          "textValue": {
+            "type": "string"
+          },
+          "anotherValue": {
+            "type": "object",
+            "properties": {
+              "xt": {
+                "type": "astd"
+              }
+            },
+            "additionalProperties": {
+              "type": "FormattedText"
+            }
+          }
+        },
+        "required": []
+      }
+    }
+  ]
+}

package/src/manifest/v1/__test__/schemas/nonObjectFunctionInputComponent.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "../../v1.json",
+  "description": "t",
+  "displayName": "t",
+  "name": "test",
+  "namespace": "other",
+  "mainFunction": "main",
+  "version": "1.0.4",
+  "environment": [],
+  "functions": [
+    {
+      "entry": "main.js",
+      "name": "main",
+      "output": {
+        "responseType": "html"
+      },
+      "input": {
+        "type": "string",
+        "properties": {
+          "textValue": {
+            "type": "FormattedText"
+          },
+          "anotherValue": {
+            "type": "object",
+            "properties": {
+              "xt": {
+                "type": "FormattedText"
+              }
+            },
+            "additionalProperties": {
+              "type": "FormattedText"
+            }
+          }
+        },
+        "required": []
+      }
+    }
+  ]
+}

package/src/manifest/v1/__test__/schemas/validComponent.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "../../v1.json",
+  "description": "t",
+  "displayName": "t",
+  "name": "test",
+  "namespace": "other",
+  "mainFunction": "main",
+  "version": "1.0.4",
+  "environment": [],
+  "functions": [
+    {
+      "entry": "main.js",
+      "name": "main",
+      "output": {
+        "responseType": "html"
+      },
+      "input": {
+        "type": "object",
+        "properties": {
+          "textValue": {
+            "type": "FormattedText"
+          },
+          "anotherValue": {
+            "type": "object",
+            "properties": {
+              "xt": {
+                "type": "FormattedText"
+              }
+            },
+            "required": [],
+            "additionalProperties": {
+              "type": "FormattedText"
+            }
+          }
+        },
+        "required": []
+      }
+    }
+  ]
+}

package/src/manifest/v1/manifestModels.ts

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

package/src/manifest/v1/manifestSchemas.ts

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

package/src/manifest/v1/subSchemas.ts

@@ -0,0 +1,5 @@
+import DxComponentIcons from './DxComponentIcons.json';
+import DxComponentInputSchema from './DxComponentInputSchema.json';
+import DxContentMetaSchema from './DxContentMetaSchema.json';
+
+export { DxComponentIcons, DxComponentInputSchema, DxContentMetaSchema };