gt-sanity 0.0.6 → 1.0.0

package/src/serialization/__tests__/BaseDocumentDeserializer/fieldLevelDeserialization.test.ts

@@ -0,0 +1,107 @@
+import { PortableTextBlock } from 'sanity';
+import { expect, test } from 'vitest';
+import { fieldLevelArticle } from '../BaseDocumentSerializer/utils';
+import { getDeserialized, toPlainText } from '../helpers';
+
+test('Global test of working field-level functionality and snapshot match', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  expect(deserialized).toMatchSnapshot();
+});
+
+/*
+ * Top-level plain text
+ */
+
+test('String and text types get deserialized correctly at top-level -- field level', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  expect(deserialized.title.en).toEqual(fieldLevelArticle.title.en);
+  expect(deserialized.snippet.en).toEqual(fieldLevelArticle.snippet.en);
+});
+
+/*
+ * Presence and accuracy of fields in "vanilla" deserialization -- objects
+ */
+test('Nested object contains accurate values -- field level', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  const origTitle = fieldLevelArticle.config.en.title;
+  const deserializedTitle = deserialized.config.en.title;
+  expect(origTitle).toEqual(deserializedTitle);
+
+  const origBlockText = fieldLevelArticle.config.en.nestedArrayField;
+  const deserializedBlockText = deserialized.config.en.nestedArrayField;
+
+  const origKeys = origBlockText.map((block: PortableTextBlock) => block._key);
+  const deserializedKeys = deserializedBlockText.map(
+    (block: PortableTextBlock) => block._key
+  );
+
+  expect(deserializedKeys.sort()).toEqual(origKeys.sort());
+  expect(toPlainText(deserializedBlockText)).toEqual(
+    toPlainText(origBlockText)
+  );
+});
+
+test('Nested object in an object contains accurate values -- field level', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  const origNestedObject = fieldLevelArticle.config.en.objectAsField;
+  const deserializedNestedObject = deserialized.config.en.objectAsField;
+
+  expect(origNestedObject.title).toEqual(deserializedNestedObject.title);
+
+  const origKeys = origNestedObject.content.map(
+    (block: PortableTextBlock) => block._key
+  );
+  const deserializedKeys = deserializedNestedObject.content.map(
+    (block: PortableTextBlock) => block._key
+  );
+
+  expect(origKeys.sort()).toEqual(deserializedKeys.sort());
+  expect(toPlainText(deserializedNestedObject.content)).toEqual(
+    toPlainText(origNestedObject.content)
+  );
+});
+
+/*
+ * Presence and accuracy of fields in vanilla deserialization -- arrays
+ */
+
+test('Array contains all serializable blocks with keys, in order -- field level', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  const origKeys = fieldLevelArticle.content.en.map(
+    (block: PortableTextBlock) => block._key
+  );
+  const deserializedKeys = deserialized.content.en.map(
+    (block: PortableTextBlock) => block._key
+  );
+  expect(deserializedKeys.sort()).toEqual(origKeys.sort());
+});
+
+test('Array contains top-level block text -- field level', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  expect(toPlainText(deserialized.content.en)).toEqual(
+    toPlainText(fieldLevelArticle.content.en)
+  );
+});
+
+test('Object in array contains accurate values in nested object -- field level', () => {
+  const deserialized = getDeserialized(fieldLevelArticle, 'field');
+  const origTitle = fieldLevelArticle.content.en.find(
+    (block: Record<string, any>) => block._type === 'objectField'
+  ).objectAsField.title;
+  const deserializedTitle = deserialized.content.en.find(
+    (block: Record<string, any>) => block._type === 'objectField'
+  ).objectAsField.title;
+  expect(deserializedTitle).toEqual(origTitle);
+
+  const origBlockText = toPlainText(
+    fieldLevelArticle.content.en.find(
+      (block: Record<string, any>) => block._type === 'objectField'
+    ).objectAsField.content
+  ).trim();
+  const deserializedBlockText = toPlainText(
+    fieldLevelArticle.content.en.find(
+      (block: Record<string, any>) => block._type === 'objectField'
+    ).objectAsField.content
+  ).trim();
+  expect(deserializedBlockText).toEqual(origBlockText);
+});

package/src/serialization/__tests__/BaseDocumentMerger/__snapshots__/documentLevelMerge.test.ts.snap

@@ -0,0 +1,193 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global document level snapshot test 1`] = `
+{
+  "_createdAt": "2021-09-01T23:00:13Z",
+  "_id": "drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a",
+  "_rev": "fxcnqj-uew-gr7-v6r-z965tfm69",
+  "_type": "documentLevelArticle",
+  "_updatedAt": "2021-09-01T23:02:05Z",
+  "config": {
+    "_type": "objectField",
+    "nestedArrayField": [
+      {
+        "_key": "4a58adc7c507",
+        "_type": "block",
+        "children": [
+          {
+            "_key": "4f6bc15ae261",
+            "_type": "span",
+            "marks": [],
+            "text": "New text",
+          },
+        ],
+        "markDefs": [],
+        "style": "normal",
+      },
+    ],
+    "objectAsField": {
+      "_type": "childObjectField",
+      "content": [
+        {
+          "_key": "1aa228ac848b",
+          "_type": "block",
+          "children": [
+            {
+              "_key": "e2cf67af8e62",
+              "_type": "span",
+              "marks": [],
+              "text": "This is a block text 2 levels deep",
+            },
+          ],
+          "markDefs": [],
+          "style": "normal",
+        },
+      ],
+      "title": "A new nested title",
+    },
+    "title": "A new title",
+  },
+  "content": [
+    {
+      "_key": "a4d177e92666",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-18",
+          "_type": "span",
+          "marks": [],
+          "text": "New block text",
+        },
+      ],
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "c0313627775e",
+      "_type": "objectField",
+      "objectAsField": {
+        "_type": "childObjectField",
+        "content": [
+          {
+            "_key": "4f24f6fbfae7",
+            "_type": "block",
+            "children": [
+              {
+                "_key": "d68f4288f5b7",
+                "_type": "span",
+                "marks": [],
+                "text": "This is block text in a nested object in an object in top-level block text.",
+              },
+            ],
+            "markDefs": [],
+            "style": "normal",
+          },
+        ],
+        "title": "This is a nested object in an object in top-level block text.",
+      },
+      "title": "This is an object in top-level block text.",
+    },
+    {
+      "_key": "9e2ab13c6d63",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "17e856dc4766",
+          "_type": "span",
+          "marks": [],
+          "text": "This is h1 text",
+        },
+      ],
+      "markDefs": [],
+      "style": "h1",
+    },
+    {
+      "_key": "297142fbaf21",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "0b2f9e94a161",
+          "_type": "span",
+          "marks": [],
+          "text": "This is h2 text",
+        },
+      ],
+      "markDefs": [],
+      "style": "h2",
+    },
+    {
+      "_key": "76e648fc3845",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "49f466bbc78c",
+          "_type": "span",
+          "marks": [],
+          "text": "Bullet 1",
+        },
+      ],
+      "level": 1,
+      "listItem": "bullet",
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "d090cd8b27d2",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "599c6991018f",
+          "_type": "span",
+          "marks": [],
+          "text": "nested bullet a",
+        },
+      ],
+      "level": 2,
+      "listItem": "bullet",
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "1cdffa5d50f5",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "c16eb16f01cb",
+          "_type": "span",
+          "marks": [],
+          "text": "Styled bullet 2",
+        },
+      ],
+      "level": 1,
+      "listItem": "bullet",
+      "markDefs": [],
+      "style": "h2",
+    },
+    {
+      "_key": "da29f5063059",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "e3d7e3eaad54",
+          "_type": "span",
+          "marks": [],
+          "text": "Number 1",
+        },
+      ],
+      "level": 1,
+      "listItem": "number",
+      "markDefs": [],
+      "style": "h3",
+    },
+  ],
+  "hidden": true,
+  "meta": "Do not translate this",
+  "snippet": "A new document snippet",
+  "tags": [
+    "tag 1",
+    "tag 2",
+    "tag 3",
+  ],
+  "title": "A new document title",
+}
+`;

package/src/serialization/__tests__/BaseDocumentMerger/__snapshots__/fieldLevelMerge.test.ts.snap

@@ -0,0 +1,97 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global field level snapshot test 1`] = `
+{
+  "_id": "drafts.2947533e-1ea5-4116-955b-339608d3445d",
+  "_rev": "l58oha-n06-1s4-f6i-74g6cuakl",
+  "_type": "fieldLevelArticle",
+  "config.es_ES": {
+    "_type": "objectField",
+    "nestedArrayField": [
+      {
+        "_key": "f49b4d7e3e51",
+        "_type": "block",
+        "children": [
+          {
+            "_key": "a6170f21181c",
+            "_type": "span",
+            "marks": [],
+            "text": "New text",
+          },
+        ],
+        "markDefs": [],
+        "style": "normal",
+      },
+    ],
+    "objectAsField": {
+      "_type": "childObjectField",
+      "content": [
+        {
+          "_key": "869168fe3a2a",
+          "_type": "block",
+          "children": [
+            {
+              "_key": "10d423df228a",
+              "_type": "span",
+              "marks": [],
+              "text": "This is block text 2 levels deep",
+            },
+          ],
+          "markDefs": [],
+          "style": "normal",
+        },
+      ],
+      "title": "A new nested title",
+    },
+    "title": "A new title",
+  },
+  "content.es_ES": [
+    {
+      "_key": "e2a39d768ff8",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-18",
+          "_type": "span",
+          "marks": [],
+          "text": "New block text",
+        },
+      ],
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "271b0c6ee984",
+      "_type": "objectField",
+      "objectAsField": {
+        "_type": "childObjectField",
+        "content": [
+          {
+            "_key": "4f24f6fbfae7",
+            "_type": "block",
+            "children": [
+              {
+                "_key": "d68f4288f5b7",
+                "_type": "span",
+                "marks": [],
+                "text": "This is block text in a nested object in an object in top-level block text.",
+              },
+            ],
+            "markDefs": [],
+            "style": "normal",
+          },
+        ],
+        "title": "This is a nested object in an object in top-level block text.",
+      },
+      "title": "This is an object in top-level block text.",
+    },
+  ],
+  "snippet.es_ES": "A new document snippet",
+  "tags.es_ES": [
+    "tag 1",
+    "tag 2",
+    "tag 3",
+  ],
+  "title.es_ES": "A new document title",
+}
+`;

package/src/serialization/__tests__/BaseDocumentMerger/baseMerge.test.ts

@@ -0,0 +1,36 @@
+import { createRequire } from 'module';
+import { PortableTextBlock } from 'sanity';
+import { expect, test } from 'vitest';
+import { BaseDocumentMerger } from '../../index';
+import { getNewDocument } from './utils';
+
+const require = createRequire(import.meta.url);
+
+const documentLevelArticle = require('../__fixtures__/documentLevelArticle.json');
+
+/*
+ * STYLE TAGS
+ */
+test('Merged document should maintain style tags', () => {
+  const newDocument = getNewDocument();
+  const mergedDocument = BaseDocumentMerger.documentLevelMerge(
+    newDocument,
+    documentLevelArticle
+  );
+  const origH1Block = documentLevelArticle.content.find(
+    (block: PortableTextBlock) => block.style === 'h1'
+  );
+  const origH2Block = documentLevelArticle.content.find(
+    (block: PortableTextBlock) => block.style === 'h2'
+  );
+  const mergedH1Block = mergedDocument.content.find(
+    (block: PortableTextBlock) => block.style === 'h1'
+  );
+  const mergedH2Block = mergedDocument.content.find(
+    (block: PortableTextBlock) => block.style === 'h2'
+  );
+  expect(mergedH1Block).toBeDefined();
+  expect(mergedH2Block).toBeDefined();
+  expect(mergedH1Block._key).toEqual(origH1Block._key);
+  expect(mergedH2Block._key).toEqual(origH2Block._key);
+});

package/src/serialization/__tests__/BaseDocumentMerger/documentLevelMerge.test.ts

@@ -0,0 +1,96 @@
+import { createRequire } from 'module';
+import { expect, test } from 'vitest';
+import { BaseDocumentMerger } from '../../index';
+import { getNewDocument, getNewObject } from './utils';
+
+const require = createRequire(import.meta.url);
+
+const documentLevelArticle = require('../__fixtures__/documentLevelArticle.json');
+
+const newDocument = getNewDocument();
+const mergedDocument = BaseDocumentMerger.documentLevelMerge(
+  newDocument,
+  documentLevelArticle
+);
+
+test('Global document level snapshot test', () => {
+  expect(mergedDocument).toMatchSnapshot();
+});
+
+/*
+ * Objects
+ */
+test('Top-level string / text fields from new document override old document', () => {
+  expect(mergedDocument.title).toEqual(newDocument.title);
+  expect(mergedDocument.snippet).toEqual(newDocument.snippet);
+  expect(mergedDocument.title).not.toEqual(documentLevelArticle.title);
+  expect(mergedDocument.snippet).not.toEqual(documentLevelArticle.snippet);
+});
+
+test('Nested object fields override old object fields', () => {
+  expect(mergedDocument.config.title).toEqual(newDocument.config.title);
+  expect(mergedDocument.config.title).not.toEqual(
+    documentLevelArticle.config.title
+  );
+  expect(mergedDocument.config.nestedArrayField[0].children[0].text).toEqual(
+    newDocument.config.nestedArrayField[0].children[0].text
+  );
+  expect(
+    mergedDocument.config.nestedArrayField[0].children[0].text
+  ).not.toEqual(
+    documentLevelArticle.config.nestedArrayField[0].children[0].text
+  );
+});
+
+test('Nested object merge uses old fields when not present on new object', () => {
+  expect(newDocument.config.objectAsField.content).toBeUndefined();
+  expect(mergedDocument.config.objectAsField.content).toBeDefined();
+});
+
+/*
+ * Arrays
+ */
+test('Arrays will use new objects when they exist', () => {
+  expect(mergedDocument.content[0].children[0].text).toEqual(
+    newDocument.content[0].children[0].text
+  );
+  expect(mergedDocument.content[0].children[0].text).not.toEqual(
+    documentLevelArticle.content[0].children[0].text
+  );
+});
+
+test('Arrays will use old blocks if they do not exist on new object', () => {
+  expect(newDocument.content[1]).toBeUndefined();
+  expect(mergedDocument.content[1]).toBeDefined();
+  expect(mergedDocument.content[1]._key).toEqual(
+    documentLevelArticle.content[1]._key
+  );
+});
+
+test('Arrays will merge objects in the array', () => {
+  const documentWithIncompleteObj = getNewDocument();
+  const incompleteObj = getNewObject();
+
+  //add a new block with some new content, but not all new content
+  documentWithIncompleteObj.content.push({
+    _key: documentLevelArticle.content[1]._key,
+    objectAsField: incompleteObj.objectAsField,
+    title: incompleteObj.title,
+  });
+  const documentWithMergedObj = BaseDocumentMerger.documentLevelMerge(
+    documentWithIncompleteObj,
+    documentLevelArticle
+  );
+
+  expect(documentWithMergedObj.content[1].title).toEqual(
+    documentWithIncompleteObj.content[1].title
+  );
+  expect(documentWithMergedObj.content[1].objectAsField.title).toEqual(
+    documentWithIncompleteObj.content[1].objectAsField.title
+  );
+  //content existed on old doc but not new, so the two coexist happily
+  expect(
+    documentWithIncompleteObj.content[1].objectAsField.content
+  ).toBeUndefined();
+  expect(documentWithMergedObj.content[1].objectAsField.content).toBeDefined();
+});

package/src/serialization/__tests__/BaseDocumentMerger/fieldLevelMerge.test.ts

@@ -0,0 +1,142 @@
+import { createRequire } from 'module';
+import { expect, test } from 'vitest';
+import { BaseDocumentMerger } from '../../index';
+import { getDeserialized } from '../helpers';
+import { getNewFieldLevelDocument, getNewObject } from './utils';
+import clone from 'just-clone';
+
+const require = createRequire(import.meta.url);
+
+const fieldLevelArticle = require('../__fixtures__/fieldLevelArticle.json');
+const nestedLanguageFields = require('../__fixtures__/nestedLanguageFields.json');
+
+const newDocument = getNewFieldLevelDocument();
+const fieldLevelPatches = BaseDocumentMerger.fieldLevelMerge(
+  newDocument,
+  fieldLevelArticle,
+  'es_ES',
+  'en'
+);
+test('Global field level snapshot test', () => {
+  expect(fieldLevelPatches).toMatchSnapshot();
+});
+
+/*
+ * Objects
+ */
+test('Top-level string / text fields from new document patch to new field, and will be maintained in old field', () => {
+  expect(fieldLevelPatches['title.es_ES']).toEqual(newDocument.title.en);
+  expect(fieldLevelPatches['snippet.es_ES']).toEqual(newDocument.snippet.en);
+  expect(fieldLevelPatches['title.es_ES']).not.toEqual(
+    fieldLevelArticle.title.en
+  );
+  expect(fieldLevelPatches['snippet.es_ES']).not.toEqual(
+    fieldLevelArticle.snippet.en
+  );
+  expect(fieldLevelPatches['title.en']).toBeUndefined();
+  expect(fieldLevelPatches['snippet.en']).toBeUndefined();
+});
+
+test('Nested object fields override old object fields', () => {
+  expect(fieldLevelPatches['config.es_ES'].title).toEqual(
+    newDocument.config.en.title
+  );
+  expect(fieldLevelPatches['config.es_ES'].title).not.toEqual(
+    fieldLevelArticle.config.en.title
+  );
+  expect(
+    fieldLevelPatches['config.es_ES'].nestedArrayField[0].children[0].text
+  ).toEqual(newDocument.config.en.nestedArrayField[0].children[0].text);
+  expect(
+    fieldLevelPatches['config.es_ES'].nestedArrayField[0].children[0].text
+  ).not.toEqual(
+    fieldLevelArticle.config.en.nestedArrayField[0].children[0].text
+  );
+});
+
+test('Nested object merge uses old fields when not present on new object', () => {
+  expect(fieldLevelPatches['config.es_ES'].objectAsField.content).toEqual(
+    fieldLevelArticle.config.en.objectAsField.content
+  );
+});
+
+/*
+ * Arrays
+ */
+test('Arrays will use new objects when they exist', () => {
+  expect(fieldLevelPatches['content.es_ES'][0].children[0].text).toEqual(
+    newDocument.content.en[0].children[0].text
+  );
+  expect(fieldLevelPatches['content.es_ES'][0].children[0].text).not.toEqual(
+    fieldLevelArticle.content.en[0].children[0].text
+  );
+});
+
+test('Arrays will use old blocks if they do not exist on new object', () => {
+  expect(newDocument.content.en[1]).toBeUndefined();
+  expect(fieldLevelPatches['content.es_ES'][1]).toBeDefined();
+  expect(fieldLevelPatches['content.es_ES'][1]._key).toEqual(
+    fieldLevelArticle.content.en[1]._key
+  );
+});
+
+test('Arrays will merge objects in the array', () => {
+  const documentWithIncompleteObj = getNewFieldLevelDocument();
+  const incompleteObj = getNewObject();
+
+  //add a new block with some new content, but not all new content
+  documentWithIncompleteObj.content.en.push({
+    _key: fieldLevelArticle.content.en[1]._key,
+    objectAsField: incompleteObj.objectAsField,
+    title: incompleteObj.title,
+    //does not include "content" field -- we want that to be merged with the old
+  });
+
+  const fieldDocWithMergedObj = BaseDocumentMerger.fieldLevelMerge(
+    documentWithIncompleteObj,
+    fieldLevelArticle,
+    'es_ES',
+    'en'
+  );
+
+  expect(fieldDocWithMergedObj['content.es_ES'][1].title).toEqual(
+    documentWithIncompleteObj.content.en[1].title
+  );
+  expect(fieldDocWithMergedObj['content.es_ES'][1].objectAsField.title).toEqual(
+    documentWithIncompleteObj.content.en[1].objectAsField.title
+  );
+  //"content" field existed on old doc but not new, so the two coexist happily
+  expect(
+    documentWithIncompleteObj.content.en[1].objectAsField.content
+  ).toBeUndefined();
+  expect(
+    fieldDocWithMergedObj['content.es_ES'][1].objectAsField.content
+  ).toBeDefined();
+});
+
+test('nested locale fields will be merged', () => {
+  const newNestedFields = clone(nestedLanguageFields);
+  newNestedFields.pageFields.name.en = 'This is a new page field name';
+  newNestedFields.slices[0].en[0].children[0].text = 'This is new slice text';
+  const baseDocumentWithNestedFields = {
+    ...fieldLevelArticle,
+    ...nestedLanguageFields,
+  };
+  const newDocumentWithNestedFields = getDeserialized(
+    { ...fieldLevelArticle, ...newNestedFields },
+    'field'
+  );
+  const nestedFieldLevelPatches = BaseDocumentMerger.fieldLevelMerge(
+    newDocumentWithNestedFields,
+    baseDocumentWithNestedFields,
+    'es_ES',
+    'en'
+  );
+
+  expect(
+    nestedFieldLevelPatches['slices[0].es_ES'][0].children[0].text
+  ).toEqual(newDocumentWithNestedFields.slices[0].en[0].children[0].text);
+  expect(nestedFieldLevelPatches['pageFields.name.es_ES']).toEqual(
+    newDocumentWithNestedFields.pageFields.name.en
+  );
+});