gt-sanity 0.0.5 → 1.0.0

package/src/serialization/__tests__/BaseDocumentDeserializer/__snapshots__/documentLevelDeserialization.test.ts.snap

@@ -0,0 +1,189 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global test of working doc-level functionality and snapshot match 1`] = `
+{
+  "_id": "drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a",
+  "_rev": "fxcnqj-uew-gr7-v6r-z965tfm69",
+  "_type": "documentLevelArticle",
+  "config": {
+    "_type": "objectField",
+    "nestedArrayField": [
+      {
+        "_key": "4a58adc7c507",
+        "_type": "block",
+        "children": [
+          {
+            "_key": "randomKey-16",
+            "_type": "span",
+            "marks": [],
+            "text": "This is block text 1 level deep",
+          },
+        ],
+        "markDefs": [],
+        "style": "normal",
+      },
+    ],
+    "objectAsField": {
+      "_type": "childObjectField",
+      "content": [
+        {
+          "_key": "1aa228ac848b",
+          "_type": "block",
+          "children": [
+            {
+              "_key": "randomKey-14",
+              "_type": "span",
+              "marks": [],
+              "text": "This is a block text 2 levels deep",
+            },
+          ],
+          "markDefs": [],
+          "style": "normal",
+        },
+      ],
+      "title": "This is one level deeper",
+    },
+    "title": "This is an object nested in a document",
+  },
+  "content": [
+    {
+      "_key": "a4d177e92666",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-18",
+          "_type": "span",
+          "marks": [],
+          "text": "This is block text at the top level.",
+        },
+      ],
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "c0313627775e",
+      "_type": "objectField",
+      "objectAsField": {
+        "_type": "childObjectField",
+        "content": [
+          {
+            "_key": "4f24f6fbfae7",
+            "_type": "block",
+            "children": [
+              {
+                "_key": "randomKey-24",
+                "_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": "randomKey-26",
+          "_type": "span",
+          "marks": [],
+          "text": "This is h1 text",
+        },
+      ],
+      "markDefs": [],
+      "style": "h1",
+    },
+    {
+      "_key": "297142fbaf21",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-28",
+          "_type": "span",
+          "marks": [],
+          "text": "This is h2 text",
+        },
+      ],
+      "markDefs": [],
+      "style": "h2",
+    },
+    {
+      "_key": "76e648fc3845",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-32",
+          "_type": "span",
+          "marks": [],
+          "text": "Bullet 1",
+        },
+      ],
+      "level": 1,
+      "listItem": "bullet",
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "d090cd8b27d2",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-36",
+          "_type": "span",
+          "marks": [],
+          "text": "nested bullet a",
+        },
+      ],
+      "level": 2,
+      "listItem": "bullet",
+      "markDefs": [],
+      "style": "normal",
+    },
+    {
+      "_key": "1cdffa5d50f5",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-42",
+          "_type": "span",
+          "marks": [],
+          "text": "Styled bullet 2",
+        },
+      ],
+      "level": 1,
+      "listItem": "bullet",
+      "markDefs": [],
+      "style": "h2",
+    },
+    {
+      "_key": "da29f5063059",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-48",
+          "_type": "span",
+          "marks": [],
+          "text": "Number 1",
+        },
+      ],
+      "level": 1,
+      "listItem": "number",
+      "markDefs": [],
+      "style": "h3",
+    },
+  ],
+  "snippet": "This is text in my text field.",
+  "tags": [
+    "tag 1",
+    "tag 2",
+    "tag 3",
+  ],
+  "title": "My Document-Level Article",
+}
+`;

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

@@ -0,0 +1,107 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global test of working field-level functionality and snapshot match 1`] = `
+{
+  "_id": "drafts.2947533e-1ea5-4116-955b-339608d3445d",
+  "_rev": "l58oha-n06-1s4-f6i-74g6cuakl",
+  "_type": "fieldLevelArticle",
+  "config": {
+    "en": {
+      "_type": "objectField",
+      "nestedArrayField": [
+        {
+          "_key": "f49b4d7e3e51",
+          "_type": "block",
+          "children": [
+            {
+              "_key": "randomKey-16",
+              "_type": "span",
+              "marks": [],
+              "text": "This is block text 1 level deep",
+            },
+          ],
+          "markDefs": [],
+          "style": "normal",
+        },
+      ],
+      "objectAsField": {
+        "_type": "childObjectField",
+        "content": [
+          {
+            "_key": "869168fe3a2a",
+            "_type": "block",
+            "children": [
+              {
+                "_key": "randomKey-14",
+                "_type": "span",
+                "marks": [],
+                "text": "This is block text 2 levels deep",
+              },
+            ],
+            "markDefs": [],
+            "style": "normal",
+          },
+        ],
+        "title": "This is one level deeper",
+      },
+      "title": "This is an object nested in a document",
+    },
+  },
+  "content": {
+    "en": [
+      {
+        "_key": "e2a39d768ff8",
+        "_type": "block",
+        "children": [
+          {
+            "_key": "randomKey-18",
+            "_type": "span",
+            "marks": [],
+            "text": "This is block text at the top level.",
+          },
+        ],
+        "markDefs": [],
+        "style": "normal",
+      },
+      {
+        "_key": "271b0c6ee984",
+        "_type": "objectField",
+        "objectAsField": {
+          "_type": "childObjectField",
+          "content": [
+            {
+              "_key": "4f24f6fbfae7",
+              "_type": "block",
+              "children": [
+                {
+                  "_key": "randomKey-24",
+                  "_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": {
+    "en": "This is text in my text field",
+  },
+  "tags": {
+    "en": [
+      "tag 1",
+      "tag 2",
+      "tag 3",
+    ],
+  },
+  "title": {
+    "en": "My Field-Level Article",
+  },
+}
+`;

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

@@ -0,0 +1,397 @@
+import { readFileSync } from 'fs';
+import {
+  PortableTextBlock,
+  PortableTextObject,
+  PortableTextSpan,
+  PortableTextTextBlock,
+} from 'sanity';
+import { beforeEach, expect, test, vi } from 'vitest';
+import {
+  BaseDocumentDeserializer,
+  BaseDocumentSerializer,
+  customBlockDeserializers,
+  defaultStopTypes,
+} from '../../index';
+import {
+  annotationAndInlineBlocks,
+  documentLevelArticle,
+  inlineDocumentLevelArticle,
+  inlineSchema,
+  schema,
+} from '../BaseDocumentSerializer/utils';
+import {
+  addedBlockDeserializers,
+  addedCustomDeserializers,
+  addedCustomSerializers,
+  getDeserialized,
+} from '../helpers';
+
+const customStyles = require('../__fixtures__/customStyles');
+
+let mockTestKey = 0;
+
+vi.mock('@sanity/block-tools', async () => {
+  const originalModule = await vi.importActual<
+    typeof import('@sanity/block-tools')
+  >('@sanity/block-tools');
+  return {
+    ...originalModule,
+    //not ideal but vi.mock('@sanity/block-tools/src/util/randomKey.ts' is not working
+    htmlToBlocks: (html: string, blockContentType: any, options: any) => {
+      const blocks = originalModule.htmlToBlocks(
+        html,
+        blockContentType,
+        options
+      );
+      const newBlocks = blocks.map((block) => {
+        const newChildren = (
+          block as unknown as PortableTextTextBlock<
+            PortableTextSpan | PortableTextObject
+          >
+        ).children.map((child) => {
+          return { ...child, _key: `randomKey-${mockTestKey++}` };
+        });
+        return {
+          ...block,
+          children: newChildren,
+          _key: `randomKey-${mockTestKey++}`,
+        };
+      });
+      return newBlocks;
+    },
+  };
+});
+
+beforeEach(() => {
+  mockTestKey = 0;
+});
+
+test('Contains id of original document', () => {
+  const deserialized = getDeserialized(documentLevelArticle, 'document');
+  const id = deserialized._id;
+  expect(id).toEqual(documentLevelArticle._id);
+});
+
+test('Contains rev of original document', () => {
+  const deserialized = getDeserialized(documentLevelArticle, 'document');
+  const rev = deserialized._rev;
+  expect(rev).toEqual(documentLevelArticle._rev);
+});
+
+test('Contains type of original document', () => {
+  const deserialized = getDeserialized(documentLevelArticle, 'document');
+  const type = deserialized._type;
+  expect(type).toEqual(documentLevelArticle._type);
+});
+
+/*
+ * CUSTOM SETTINGS
+ */
+
+test('Custom deserialization should manifest at all levels', () => {
+  const serialized = BaseDocumentSerializer(schema).serializeDocument(
+    documentLevelArticle,
+    'document',
+    'en',
+    defaultStopTypes,
+    addedCustomSerializers
+  );
+
+  const deserialized = BaseDocumentDeserializer.deserializeDocument(
+    serialized.content,
+    addedCustomDeserializers,
+    customBlockDeserializers
+  );
+  expect(deserialized.config.title).toEqual(documentLevelArticle.config.title);
+  expect(deserialized.config._type).toEqual(documentLevelArticle.config._type);
+
+  const origArrayObj = documentLevelArticle.content.find(
+    (b: Record<string, any>) => b._type === 'objectField'
+  );
+  const deserializedArrayObj = deserialized.content.find(
+    (b: Record<string, any>) => b._type === 'objectField'
+  );
+
+  expect(deserializedArrayObj.title).toEqual(origArrayObj.title);
+  expect(deserializedArrayObj._key).toEqual(origArrayObj._key);
+});
+
+test('Content with custom styles deserializes correctly and maintains style', () => {
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+  const customStyledDocument = {
+    ...documentLevelArticle,
+    ...customStyles,
+  };
+
+  const serialized = BaseDocumentSerializer(schema).serializeDocument(
+    customStyledDocument,
+    'document'
+  );
+
+  const deserialized = BaseDocumentDeserializer.deserializeDocument(
+    serialized.content
+  );
+  const origCustomStyleBlock = customStyledDocument.content.find(
+    (b: Record<string, any>) => b._type === 'block' && b.style === 'custom1'
+  );
+  const origCustomStyleListItem = customStyledDocument.content.find(
+    (b: Record<string, any>) =>
+      b._type === 'block' && b.listItem === 'number' && b.style === 'custom1'
+  );
+  const deserializedCustomStyleBlock = deserialized.content.find(
+    (b: Record<string, any>) => b._type === 'block' && b.style === 'custom1'
+  );
+  const deserializedCustomStyleListItem = deserialized.content.find(
+    (b: Record<string, any>) =>
+      b._type === 'block' && b.listItem === 'number' && b.style === 'custom1'
+  );
+
+  expect(deserializedCustomStyleBlock.children[0].text).toEqual(
+    origCustomStyleBlock.children[0].text
+  );
+
+  expect(deserializedCustomStyleListItem.children[0].text).toEqual(
+    origCustomStyleListItem.children[0].text
+  );
+});
+
+//test -- unhandled annotations and inlines don't break when they get deserialized back
+test('Handled inline objects should be accurately deserialized', () => {
+  const inlineDocument = {
+    ...documentLevelArticle,
+    ...annotationAndInlineBlocks,
+  };
+
+  const serialized = BaseDocumentSerializer(schema).serializeDocument(
+    inlineDocument,
+    'document',
+    'en',
+    defaultStopTypes,
+    addedCustomSerializers
+  );
+
+  const deserialized = BaseDocumentDeserializer.deserializeDocument(
+    serialized.content,
+    addedCustomDeserializers,
+    addedBlockDeserializers
+  );
+
+  const getInlineObj = (
+    content: PortableTextBlock[],
+    level: number | undefined = undefined
+  ) => {
+    let child: Record<string, any> = {};
+    const blocks = content.filter((block: PortableTextBlock) => {
+      if (level) {
+        return block.level === level;
+      }
+      return !block.level;
+    });
+
+    blocks.forEach((block: PortableTextBlock) => {
+      if (block.children && Array.isArray(block.children)) {
+        child = block.children.find((span: Record<string, any>) => {
+          if (level) {
+            return span._type === 'childObjectField' && block.level === level;
+          }
+          return span._type === 'childObjectField' && !block.level;
+        });
+      }
+    });
+
+    return child;
+  };
+  const origInlineObject = getInlineObj(inlineDocument.content);
+  const origInlineListObject = getInlineObj(inlineDocument.content, 1);
+
+  const deserializedInlineObject = getInlineObj(deserialized.content);
+  const deserializedInlineListObject = getInlineObj(deserialized.content, 1);
+
+  expect(deserializedInlineObject.title).toEqual(origInlineObject.title);
+  expect(deserializedInlineObject._type).toEqual(origInlineObject._type);
+
+  expect(deserializedInlineListObject.title).toEqual(
+    origInlineListObject.title
+  );
+  expect(deserializedInlineListObject._type).toEqual(
+    origInlineListObject._type
+  );
+});
+
+test('Handled annotations should be accurately deserialized', () => {
+  const inlineDocument = {
+    ...documentLevelArticle,
+    ...annotationAndInlineBlocks,
+  };
+
+  const serialized = BaseDocumentSerializer(schema).serializeDocument(
+    inlineDocument,
+    'document',
+    'en',
+    defaultStopTypes,
+    addedCustomSerializers
+  );
+
+  const deserialized = BaseDocumentDeserializer.deserializeDocument(
+    serialized.content,
+    addedCustomDeserializers,
+    addedBlockDeserializers
+  );
+
+  let origAnnotation: Record<string, any> | null = null;
+  let deserializedAnnotation: Record<string, any> | null = null;
+
+  inlineDocument.content.forEach((block: PortableTextBlock) => {
+    if (block.children && Array.isArray(block.children)) {
+      block.children.forEach((span: Record<string, any>) => {
+        if (span.marks && span.marks.length) {
+          origAnnotation = span;
+        }
+      });
+    }
+  });
+
+  deserialized.content.forEach((block: PortableTextBlock) => {
+    if (block.children && Array.isArray(block.children)) {
+      block.children.forEach((span: Record<string, any>) => {
+        if (span.marks && span.marks.length) {
+          deserializedAnnotation = span;
+        }
+      });
+    }
+  });
+
+  expect(deserializedAnnotation!.text).toEqual(origAnnotation!.text);
+});
+
+/*
+ * STYLE TAGS
+ */
+test('Deserialized content should preserve style tags', () => {
+  const deserialized = getDeserialized(documentLevelArticle, 'document');
+  const origH1 = documentLevelArticle.content.find(
+    (block: PortableTextBlock) => block.style === 'h1'
+  );
+  const deserializedH1 = deserialized.content.find(
+    (block: PortableTextBlock) => block.style === 'h1'
+  );
+  const origH2 = documentLevelArticle.content.find(
+    (block: PortableTextBlock) => block.style === 'h2'
+  );
+  const deserializedH2 = deserialized.content.find(
+    (block: PortableTextBlock) => block.style === 'h2'
+  );
+  expect(deserializedH1).toBeDefined();
+  expect(deserializedH2).toBeDefined();
+  expect(deserializedH1._key).toEqual(origH1._key);
+  expect(deserializedH2._key).toEqual(origH2._key);
+  expect(deserializedH1.children[0].text).toEqual(origH1.children[0].text);
+  expect(deserializedH2.children[0].text).toEqual(origH2.children[0].text);
+});
+
+/*
+ * LIST ITEMS
+ */
+test('Deserialized list items should preserve level, style and tag', () => {
+  const deserialized = getDeserialized(documentLevelArticle, 'document');
+  const origListItem = documentLevelArticle.content.find(
+    (block: PortableTextBlock) =>
+      block.listItem === 'bullet' && block.style === 'h2'
+  );
+  const deserializedListItem = deserialized.content.find(
+    (block: PortableTextBlock) =>
+      block.listItem === 'bullet' && block.style === 'h2'
+  );
+  const origNestedListItem = documentLevelArticle.content.find(
+    (block: PortableTextBlock) =>
+      block.listItem === 'bullet' && block.level === 2
+  );
+  const deserializedNestedListItem = deserialized.content.find(
+    (block: PortableTextBlock) =>
+      block.listItem === 'bullet' && block.level === 2
+  );
+  expect(deserializedListItem).toBeDefined();
+  expect(deserializedNestedListItem).toBeDefined();
+  expect(deserializedListItem._key).toEqual(origListItem._key);
+  expect(deserializedNestedListItem._key).toEqual(origNestedListItem._key);
+  expect(deserializedListItem.children[0].text).toEqual(
+    origListItem.children[0].text
+  );
+  expect(deserializedNestedListItem.children[0].text).toEqual(
+    origNestedListItem.children[0].text
+  );
+});
+
+/*
+ * MESSY INPUT
+ */
+test('&nbsp; whitespace should not be escaped', () => {
+  vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+  const content = readFileSync(
+    'src/serialization/__tests__/__fixtures__/messy-html.html',
+    {
+      encoding: 'utf-8',
+    }
+  );
+  const result = BaseDocumentDeserializer.deserializeDocument(content);
+  expect(result.title).toEqual('Här är artikel titeln');
+  expect(result.content[1].nestedArrayField[0].title).toEqual(
+    'Det här är en dragspels titeln'
+  );
+});
+
+/*
+ * V2 functionality -- be able to operate without a strict schema
+ */
+test('Content with anonymous inline objects deserializes all fields, at any depth', () => {
+  vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+  const serialized = BaseDocumentSerializer(inlineSchema).serializeDocument(
+    inlineDocumentLevelArticle,
+    'document'
+  );
+
+  const deserialized = BaseDocumentDeserializer.deserializeDocument(
+    serialized.content
+  );
+  //object in field
+  expect(deserialized.tabs.config.title).toEqual(
+    inlineDocumentLevelArticle.tabs.config.title
+  );
+
+  //array in object in object
+  expect(
+    deserialized.tabs.config.objectAsField.content[0].children[0].text
+  ).toEqual(
+    inlineDocumentLevelArticle.tabs.config.objectAsField.content[0].children[0]
+      .text
+  );
+
+  //arrays
+  expect(deserialized.tabs.content).toBeInstanceOf(Array);
+  expect(deserialized.tabs.content.map((block: any) => block._key)).toEqual(
+    inlineDocumentLevelArticle.tabs.content.map((block: any) => block._key)
+  );
+
+  //object in array
+  const origObj = inlineDocumentLevelArticle.tabs.content.find(
+    (block: any) => block._type === 'objectField'
+  );
+  const deserializedObj = deserialized.tabs.content.find(
+    (block: any) => block._type === 'objectField'
+  );
+
+  expect(deserializedObj.title).toEqual(origObj.title);
+  expect(deserializedObj.objectAsField.content[0].children[0].text).toEqual(
+    origObj.objectAsField.content[0].children[0].text
+  );
+
+  //anonymous object in array
+  const origArray = inlineDocumentLevelArticle.tabs.arrayWithAnonymousObjects;
+  const deserializedArray = deserialized.tabs.arrayWithAnonymousObjects;
+  expect(deserializedArray.length).toEqual(origArray.length);
+  expect(deserializedArray[0]._key).toEqual(origArray[0]._key);
+  expect(Object.keys(deserializedArray[0])).not.toContain('span');
+});