@atlaskit/adf-schema 37.0.3 → 37.1.20

package/dist/types/next-schema/nodes/unsupportedInline.d.ts

@@ -7,6 +7,8 @@ export declare const unsupportedInline: import("@atlaskit/adf-schema-generator/d
     inline?: true;
     code?: boolean;
     content?: import("@atlaskit/adf-schema-generator/dist/types/types/ADFNodeSpec").ADFNodeContentSpec[];
+    contentMinItems?: number;
+    contentMaxItems?: number;
     defining?: boolean;
     definingAsContext?: boolean;
     definingForContent?: boolean;
@@ -16,7 +18,23 @@ export declare const unsupportedInline: import("@atlaskit/adf-schema-generator/d
     marks?: import("@atlaskit/adf-schema-generator/dist/types/adfMark").ADFMark<unknown>[];
     allowAnyChildMark?: boolean;
     allowNoChildMark?: boolean;
+    noMarks?: boolean;
+    hasEmptyMarks?: boolean;
     selectable?: boolean;
     whitespace?: "pre" | "normal";
     tableRole?: "table" | "row" | "cell" | "header_cell";
+    DANGEROUS_MANUAL_OVERRIDE?: {
+        'pm-spec'?: {
+            [x: string]: {
+                value: any;
+                reason: string;
+            };
+        };
+        'validator-spec'?: {
+            [x: string]: {
+                value: any;
+                reason: string;
+            };
+        };
+    };
 }>;

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@atlaskit/adf-schema",
-  "version": "37.0.3",
+  "version": "37.1.20",
   "description": "Shared package that contains the ADF-schema (json) and ProseMirror node/mark specs",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "repository": "https://bitbucket.org/atlassian/adf-schema",
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/atlassian/adf-schema.git"
+  },
   "author": "Atlassian Pty Ltd",
   "license": "Apache-2.0",
   "main": "dist/cjs/index.js",
@@ -44,7 +47,8 @@
   },
   "devDependencies": {
     "@atlassian/adf-schema-json": "^1.16.0",
-    "@atlaskit/adf-schema-generator": "^1.17.4",
+    "@atlaskit/adf-schema-generator": "^1.24.2",
+    "@atlaskit/adf-utils": "^19.2.2",
     "@atlaskit/codemod-utils": "^4.2.4",
     "@atlaskit/json-schema-generator": "^3.3.9",
     "@babel/cli": "^7.22.9",
@@ -60,6 +64,7 @@
     "@babel/preset-typescript": "^7.22.5",
     "@compiled/babel-plugin": "0.15.0",
     "@types/jest": "^29.5.3",
+    "@types/json-schema": "^7.0.15",
     "@types/linkify-it": "^2.0.4",
     "@types/node": "^20.4.8",
     "babel-plugin-transform-define": "^2.0.0",

package/schema-generators/__tests__/unit/__fixtures__/index.fixture.ts

@@ -0,0 +1,140 @@
+import { JSONSchema4 } from 'json-schema';
+
+export const tableCellNodeContent: JSONSchema4 = {
+  type: 'array',
+  items: {
+    anyOf: [
+      {
+        $ref: '#/definitions/codeBlock_with_no_marks_node',
+      },
+      {
+        $ref: '#/definitions/blockCard_node',
+      },
+      {
+        $ref: '#/definitions/paragraph_with_no_marks_node',
+      },
+      {
+        $ref: '#/definitions/paragraph_with_alignment_node',
+      },
+      {
+        $ref: '#/definitions/mediaSingle_caption_node',
+      },
+      {
+        $ref: '#/definitions/mediaSingle_full_node',
+      },
+      {
+        $ref: '#/definitions/taskList_node',
+      },
+      {
+        $ref: '#/definitions/bulletList_node',
+      },
+      {
+        $ref: '#/definitions/orderedList_node',
+      },
+      {
+        $ref: '#/definitions/heading_with_no_marks_node',
+      },
+      {
+        $ref: '#/definitions/heading_with_alignment_node',
+      },
+      {
+        $ref: '#/definitions/heading_with_indentation_node',
+      },
+      {
+        $ref: '#/definitions/mediaGroup_node',
+      },
+      {
+        $ref: '#/definitions/decisionList_node',
+      },
+      {
+        $ref: '#/definitions/rule_node',
+      },
+      {
+        $ref: '#/definitions/panel_node',
+      },
+      {
+        $ref: '#/definitions/blockquote_node',
+      },
+      {
+        $ref: '#/definitions/extension_with_marks_node',
+      },
+      {
+        $ref: '#/definitions/embedCard_node',
+      },
+      {
+        $ref: '#/definitions/nestedExpand_with_no_marks_node',
+      },
+    ],
+  },
+  minItems: 1,
+};
+
+export const tableHeaderNodeContent: JSONSchema4 = {
+  type: 'array',
+  items: {
+    anyOf: [
+      {
+        $ref: '#/definitions/codeBlock_with_no_marks_node',
+      },
+      {
+        $ref: '#/definitions/blockCard_node',
+      },
+      {
+        $ref: '#/definitions/paragraph_with_no_marks_node',
+      },
+      {
+        $ref: '#/definitions/paragraph_with_alignment_node',
+      },
+      {
+        $ref: '#/definitions/mediaSingle_caption_node',
+      },
+      {
+        $ref: '#/definitions/mediaSingle_full_node',
+      },
+      {
+        $ref: '#/definitions/taskList_node',
+      },
+      {
+        $ref: '#/definitions/bulletList_node',
+      },
+      {
+        $ref: '#/definitions/orderedList_node',
+      },
+      {
+        $ref: '#/definitions/heading_with_no_marks_node',
+      },
+      {
+        $ref: '#/definitions/heading_with_alignment_node',
+      },
+      {
+        $ref: '#/definitions/heading_with_indentation_node',
+      },
+      {
+        $ref: '#/definitions/mediaGroup_node',
+      },
+      {
+        $ref: '#/definitions/decisionList_node',
+      },
+      {
+        $ref: '#/definitions/rule_node',
+      },
+      {
+        $ref: '#/definitions/panel_node',
+      },
+      {
+        $ref: '#/definitions/blockquote_node',
+      },
+      { $ref: '#/definitions/nestedExpand_node' },
+      {
+        $ref: '#/definitions/extension_with_marks_node',
+      },
+      {
+        $ref: '#/definitions/embedCard_node',
+      },
+      {
+        $ref: '#/definitions/nestedExpand_with_no_marks_node',
+      },
+    ],
+  },
+  minItems: 1,
+};

package/schema-generators/__tests__/unit/adfToValidatorSpec.unit.ts

@@ -13,18 +13,6 @@ test('should be able to handle the panel node', () => {
   expect(result.panel.json).toEqual(sortNestedArrays(panel));
 });
 
-test('should be able to handle mentions', () => {
-  const result = sortNestedArrays(adfToValidatorSpec(adfNode));
-
-  expect(result.mention.json).toEqual(sortNestedArrays(mention));
-});
-
-test('should be able to handle paragraphs', () => {
-  const result = sortNestedArrays(adfToValidatorSpec(adfNode));
-
-  expect(result.paragraph.json).toEqual(sortNestedArrays(paragraph));
-});
-
 // i don't know what node on the results object is nested_expand because
 // nested_expand doesn't exist in the adfNode object :hmmmmmm:
 test.skip('should be able to handle nested expand', () => {
@@ -54,39 +42,6 @@ const nested_expand = {
   required: ['content'],
 };
 
-const paragraph = {
-  props: {
-    type: { type: 'enum', values: ['paragraph'] },
-    content: {
-      type: 'array',
-      items: ['inline'],
-      allowUnsupportedInline: true, // currently not supported by DSL
-      optional: true,
-    },
-    marks: { type: 'array', items: [], optional: true },
-    attrs: { props: { localId: { type: 'string', optional: true } } },
-  },
-};
-
-const mention = {
-  props: {
-    type: { type: 'enum', values: ['mention'] },
-    attrs: {
-      props: {
-        id: { type: 'string' },
-        text: { type: 'string', optional: true },
-        userType: {
-          type: 'enum',
-          values: ['DEFAULT', 'SPECIAL', 'APP'],
-          optional: true,
-        },
-        accessLevel: { type: 'string', optional: true },
-        localId: { type: 'string', optional: true },
-      },
-    },
-  },
-};
-
 const panel = {
   props: {
     type: { type: 'enum', values: ['panel'] },
@@ -129,6 +84,7 @@ const panel = {
         ],
       ],
       minItems: 1,
+      allowUnsupportedBlock: true,
     },
   },
 };

package/schema-generators/__tests__/unit/adfToValidatorSpecValidation.unit.ts

@@ -0,0 +1,85 @@
+import { adfToValidatorSpec } from '@atlaskit/adf-schema-generator';
+import * as currentSpecs from '@atlaskit/adf-utils/dist/cjs/validator/specs';
+import adfNode from '../../../src/next-schema/full-schema.adf';
+
+const newSpecs = sortNestedArrays(adfToValidatorSpec(adfNode));
+const SKIP_LIST = [
+  'blockCard', // doesn't match existing spec
+  'bodiedExtension', // doesn't match existing spec
+  'caption', // doesn't match existing spec
+  'codeBlock', // doesn't match existing spec
+  'doc', // doesn't match existing spec
+  'expand', // doesn't match existing spec
+  'extensionFrame', // doesn't match existing spec
+  'inlineCard', // doesn't match existing spec
+  'inlineExtension', // doesn't exist in the output
+  'inline_comment_marker', // doesn't exist in the output
+  'layoutColumn', // doesn't match existing spec, wrong group name in content, allowUnsupportedBlock
+  'layoutSection', // doesn't match existing spec, maxItem/minItem, extra marks
+  'layoutSection_full', // doesn't match existing spec, allowUnsupportedBlock, extra marks
+  'layoutSection_with_single_column', // doesn't exist in the output
+  'media', // doesn't match existing spec
+  'mediaInline', // doesn't match existing spec
+  'multiBodiedExtension', // doesn't match existing spec
+  'nestedExpand', // doesn't match existing spec
+  'tableCell', // doesn't match existing spec
+  'tableHeader', // doesn't match existing spec
+  'tableRow', // doesn't match existing spec, extra minItems
+
+  'atomic_inline', // doesn't exist in the output
+  'inline', // doesn't exist in the output
+  'block_content', // doesn't exist in the output
+  'nestedExpand_content', // doesn't exist in the output
+  'non_nestable_block_content', // doesn't exist in the output
+  'tableCell_content', // doesn't exist in the output
+];
+
+const testCases = Object.entries(currentSpecs).map(([key, value]) => {
+  return {
+    name: key,
+    currentSpec: sortNestedArrays(value),
+    newSpec: sortNestedArrays(newSpecs[key]?.json),
+  };
+});
+
+testCases.forEach(({ name, currentSpec, newSpec }) => {
+  const testMethod = SKIP_LIST.includes(name) ? it.skip : it;
+  testMethod(`should be able to handle ${name}`, () => {
+    expect(newSpec).toEqual(currentSpec);
+  });
+});
+
+function sortNestedArrays(obj: any): any {
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+
+  if (
+    Array.isArray(obj) &&
+    typeof obj[0] === 'string' &&
+    typeof obj[1] === 'object'
+  ) {
+    // 1. tuple of object + string
+    obj[1] = sortNestedArrays(obj[1]);
+  } else if (Array.isArray(obj) && Array.isArray(obj[0])) {
+    // 2. array of arrays
+    for (let i = 0; i < obj.length; i++) {
+      obj[i] = sortNestedArrays(obj[i]);
+    }
+  } else if (
+    Array.isArray(obj) &&
+    !Array.isArray(obj[0]) &&
+    typeof obj[0] !== 'object'
+  ) {
+    // 3. simple array
+    obj.sort();
+  }
+  if (typeof obj === 'object') {
+    // 4. object
+    for (const key of Object.keys(obj)) {
+      obj[key] = sortNestedArrays(obj[key]);
+    }
+  }
+
+  return obj;
+}

package/schema-generators/__tests__/unit/json-full-schema-backwards-compat.unit.ts

@@ -1,65 +1,79 @@
 import { validateSchemaCompatibility } from 'json-schema-diff-validator';
 import { adfToJSON } from '@atlaskit/adf-schema-generator';
 import adfNode from '@atlaskit/adf-schema/src/next-schema/full-schema.adf';
+import {
+  tableCellNodeContent,
+  tableHeaderNodeContent,
+} from './__fixtures__/index.fixture';
 
-const DEFINITIONS_TO_SKIP_FULL = [
-  'blockCard_node',
-  'block_content',
-  'bodiedExtension_node',
-  'bodiedExtension_with_marks_node',
-  'codeBlock_node',
-  'codeBlock_with_marks_node',
-  'codeBlock_with_no_marks_node',
-  'code_inline_node',
-  'doc_node',
-  'expand_node',
-  'expand_with_breakout_mark_node',
-  'expand_with_no_mark_node',
-  'extension_node',
-  'extension_with_marks_node',
-  'formatted_text_inline_node',
-  'heading_node',
-  'heading_with_alignment_node',
-  'heading_with_indentation_node',
-  'heading_with_no_marks_node',
-  'inlineCard_node',
-  'inlineExtension_node',
-  'inlineExtension_with_marks_node',
-  'inline_node',
-  'layoutSection_full_node',
-  'mediaInline_node',
-  'mediaSingle_caption_node',
-  'mediaSingle_full_node',
-  'mediaSingle_node',
-  'nestedExpand_content',
-  'nestedExpand_node',
-  'nestedExpand_with_no_marks_node',
-  'non_nestable_block_content',
-  'paragraph_node',
-  'paragraph_with_alignment_node',
-  'paragraph_with_indentation_node',
-  'paragraph_with_no_marks_node',
-  'table_cell_content',
-  'table_cell_node',
-  'table_header_node',
-  'text_node',
-];
+declare let expect: any;
+expect.extend({
+  toBeBackwardsCompatibleWith(received, expected) {
+    try {
+      validateSchemaCompatibility(expected, received, {
+        allowNewOneOf: true,
+        allowNewEnumValue: true,
+        allowReorder: true,
+      });
+    } catch (e) {
+      if (e.name === 'AssertionError') {
+        return {
+          pass: false,
+          message: () =>
+            JSON.stringify(
+              JSON.parse(
+                e.message.replace(
+                  'The schema is not backward compatible. Difference include breaking change = ',
+                  '',
+                ),
+              ),
+              null,
+              4,
+            ),
+        };
+      }
+      return {
+        pass: false,
+        message: () => e.message,
+      };
+    }
+    return { pass: true, message: 'Schemas are compatible' };
+  },
+});
+
+// The end goal is to be able to remove all transformation for known failures
+function transformFullFixtureForKnownFailures(json) {
+  const definitions = json.definitions;
+
+  delete definitions.bodiedExtension_node;
+  delete definitions.codeBlock_node;
+  delete definitions.expand_node;
+  delete definitions.extension_node;
+  delete definitions.inlineExtension_node;
+  delete definitions.layoutSection_node;
+  delete definitions.mediaSingle_node;
+  delete definitions.nestedExpand_content;
+  delete definitions.nestedExpand_node;
+  delete definitions.nestedExpand_with_no_marks_node;
+  delete definitions.non_nestable_block_content;
+  delete definitions.table_cell_content;
+  delete definitions.mediaInline_node.properties.attrs.properties.data;
+
+  // New JSON, different to the old JSON schema
+  definitions.table_cell_node.properties.content = tableCellNodeContent;
+  definitions.table_header_node.properties.content = tableHeaderNodeContent;
+
+  return json;
+}
 
 test('ADF DSL to JSON Schema backwards compatibility for full schema', () => {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const currentSchema = require('../../../json-schema/v1/full.json');
+  const currentSchema = transformFullFixtureForKnownFailures(
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require('../../../json-schema/v1/full.json'),
+  );
   const nextSchema = adfToJSON(adfNode);
-  DEFINITIONS_TO_SKIP_FULL.forEach((definition) => {
-    nextSchema.definitions[definition] = currentSchema.definitions[definition];
-  });
 
-  expect(() => {
-    validateSchemaCompatibility(currentSchema, nextSchema, {
-      allowNewOneOf: true,
-      allowNewEnumValue: true,
-      allowReorder: true,
-    });
-  }).not.toThrow();
+  expect(nextSchema).toBeBackwardsCompatibleWith(currentSchema);
 });
 
 const DEFINITIONS_TO_SKIP_STAGE_0 = [
@@ -89,6 +103,7 @@ const DEFINITIONS_TO_SKIP_STAGE_0 = [
   'inlineExtension_node',
   'inlineExtension_with_marks_node',
   'inline_node',
+  'layoutSection_node',
   'layoutSection_full_node',
   'layoutSection_with_single_column_node',
   'mediaInline_node',
@@ -119,11 +134,5 @@ test('ADF DSL to JSON Schema backwards compatibility for stage0 schema', () => {
     nextSchema.definitions[definition] = currentSchema.definitions[definition];
   });
 
-  expect(() => {
-    validateSchemaCompatibility(currentSchema, nextSchema, {
-      allowNewOneOf: true,
-      allowNewEnumValue: true,
-      allowReorder: true,
-    });
-  }).not.toThrow();
+  expect(nextSchema).toBeBackwardsCompatibleWith(currentSchema);
 });