svedit 0.3.0 → 0.5.0

package/src/lib/{AnnotatedStringProperty.svelte → AnnotatedTextProperty.svelte}

@@ -1,12 +1,12 @@
 <script>
 	import { getContext } from 'svelte';
-	import { char_slice, get_char_length } from './util.js';
+	import { char_slice, get_char_length, snake_to_pascal } from './util.js';
 
-  /** @import { AnnotatedStringPropertyProps, Annotation, AnnotationFragment } from './types.d.ts'; */
+  /** @import { AnnotatedTextPropertyProps, Annotation, AnnotationFragment } from './types.d.ts'; */
 
 	const svedit = getContext('svedit');
 
- /** @type {AnnotatedStringPropertyProps} */
+ /** @type {AnnotatedTextPropertyProps} */
 	let {
 		path,
 		class: css_class,
@@ -20,32 +20,36 @@
 	/**
 	 * Converts text with annotations into renderable fragments for display.
 	 * @param {string} text - The plain text content
-	 * @param {Array<Annotation>} annotations - Array of annotations where each is [start_offset, end_offset, type, options?] (minimum 3 elements)
+	 * @param {Array<Annotation>} annotations - Array of annotations where each is {start_offset, end_offset, node_id}
 	 * @returns {Array<string|AnnotationFragment>} Array of fragments - strings for plain text, AnnotationFragment objects for annotated content
 	 */
-	function render_annotated_string(text, annotations) {
+	function get_fragments(text, annotations) {
 		let fragments = [];
 		let last_index = 0;
 
 		// Sort annotations by start_offset
-		const sorted_annotations = [...annotations].sort((a, b) => a[0] - b[0]);
+		const sorted_annotations = [...annotations].sort((a, b) => a.start_offset - b.start_offset);
 
-		for (let [index, annotation] of sorted_annotations.entries()) {
+		for (let [, annotation] of sorted_annotations.entries()) {
 			// Add text before the annotation using character-aware slicing
-			if (annotation[0] > last_index) {
-				fragments.push(char_slice(text, last_index, annotation[0]));
+			if (annotation.start_offset > last_index) {
+				fragments.push(char_slice(text, last_index, annotation.start_offset));
 			}
 
 			// Add the annotated string using character-aware slicing
-			const annotated_content = char_slice(text, annotation[0], annotation[1]);
+			const annotated_content = char_slice(text, annotation.start_offset, annotation.end_offset);
+			const node = svedit.doc.get(annotation.node_id);
+			if (!node) throw new Error(`Node not found for annotation ${annotation.node_id}`);
+
 			fragments.push({
-				type: annotation[2],
+			  node,
 				content: annotated_content,
-				annotation_index: index,
-				data: annotation[3]
+				// NOTE: We need to provide the original index here, because the source data
+				// is the address space.
+				annotation_index: annotations.indexOf(annotation),
 			});
 
-			last_index = annotation[1];
+			last_index = annotation.end_offset;
 		}
 
 		// Add any remaining text after the last annotation using character-aware slicing
@@ -56,15 +60,9 @@
 		return fragments;
 	}
 
-	let fragments = $derived(render_annotated_string(svedit.doc.get(path)[0], svedit.doc.get(path)[1]));
-	let plain_text = $derived(svedit.doc.get(path)[0]);
+	let fragments = $derived(get_fragments(svedit.doc.get(path).text, svedit.doc.get(path).annotations));
+	let plain_text = $derived(svedit.doc.get(path).text);
 
-	/**
-	 * @param {MouseEvent} e - The click event
-	 */
-	function handle_link_click(e) {
-		e.preventDefault();
-	}
 </script>
 
 {#key plain_text}
@@ -79,21 +77,10 @@
     placeholder={placeholder}
   >
     {#each fragments as fragment, index (index)}
-  		{#if typeof fragment === 'string'}<!--
-        -->{fragment}<!--
-      -->{:else if fragment.type === 'emphasis'}<!--
-        --><em>{fragment.content}</em><!--
-      -->{:else if fragment.type === 'strong'}<!--
-        --><strong>{fragment.content}</strong><!--
-      -->{:else if fragment.type === 'link'}<!--
-        --><a
-  				onclick={handle_link_click}
-  				style="anchor-name: --{path.join('-') + '-' + fragment.annotation_index};"
-  				href={fragment.data.href}
-  				target={fragment.data.target || '_self'}>{fragment.content}</a><!--
-      -->{:else}<!--
-        -->{fragment.content}<!--
-      -->{/if}
+  		{#if typeof fragment === 'string'}{fragment}{:else}
+        {@const AnnotationComponent = svedit.doc.config.node_components[snake_to_pascal(fragment.node.type)]}
+        <AnnotationComponent path={[...path, 'annotations', fragment.annotation_index, 'node_id']} content={fragment.content} />
+      {/if}
   	{/each}<!--
     --><br>
   </div>
@@ -118,12 +105,13 @@
 
   /* We can safely hide the <br> element when the placeholder is empty and focused. */
   /* No longer the cursor will be rendered after the placeholder when focused. */
+  /* ATTENTION: This hack has the side effect that in Safari Desktop the cursor sometimes disappears. */
   [placeholder].empty.focused br {
     display:none;
   }
 
-  .text.focused {
+  /*.text.focused {
     background: none;
-    outline: 1px dashed var(--editing-stroke-color);
-  }
+    outline: 1px solid var(--editing-stroke-color);
+  }*/
 </style>

package/src/lib/Document.svelte.js

@@ -1,5 +1,5 @@
 import Transaction from './Transaction.svelte.js';
-import { char_slice } from './util.js';
+import { char_slice, get_char_length, traverse } from './util.js';
 
 /**
  * @import {
@@ -8,9 +8,10 @@ import { char_slice } from './util.js';
  *   Selection,
  *   Annotation,
  *   PrimitiveType,
- *   DocumentSchemaPrimitive,
  *   NodeProperty,
  *   NodeArrayProperty,
+ *   NodeKind,
+ *   NodeSchema,
  *   DocumentSchema,
  *   SerializedDocument
  * } from './types.d.ts';
@@ -20,7 +21,7 @@ import { char_slice } from './util.js';
  * Identity function — keeps schema at runtime & makes IDE infer types.
  * Similar to your define_schema pattern but for document schemas.
  *
- * @template {Record<string, Record<string, {type: DocumentSchemaPrimitive}>>} S
+ * @template {Record<string, NodeSchema>} S
  * @param {S} schema - The document schema to validate
  * @returns {S} The same schema, but with type information preserved
  */
@@ -36,7 +37,7 @@ export function define_document_schema(schema) {
 export function is_primitive_type(type) {
   return [
     'string', 'number', 'boolean', 'integer', 'datetime',
-    'annotated_string', 'string_array', 'number_array',
+    'annotated_text', 'string_array', 'number_array',
     'boolean_array', 'integer_array'
   ].includes(type);
 }
@@ -63,7 +64,7 @@ export function get_default_node_type(property_definition) {
 export function validate_document_schema(document_schema) {
   // Check that all referenced node types exist
   for (const [node_type, node_schema] of Object.entries(document_schema)) {
-    for (const [prop_name, prop_def] of Object.entries(node_schema)) {
+    for (const [prop_name, prop_def] of Object.entries(node_schema.properties)) {
       if (prop_def.type === 'node' || prop_def.type === 'node_array') {
         const missing_types = prop_def.node_types.filter(ref_type => !(ref_type in document_schema));
         if (missing_types.length > 0) {
@@ -92,11 +93,11 @@ function validate_primitive_value(type, value) {
       return Number.isInteger(value);
     case 'datetime':
       return typeof value === 'string' && !isNaN(Date.parse(value));
-    case 'annotated_string':
-      return Array.isArray(value) &&
-             value.length === 2 &&
-             typeof value[0] === 'string' &&
-             Array.isArray(value[1]);
+    case 'annotated_text':
+      return typeof value === 'object' &&
+             value !== null &&
+             typeof value.text === 'string' &&
+             Array.isArray(value.annotations);
     case 'string_array':
       return Array.isArray(value) && value.every(v => typeof v === 'string');
     case 'number_array':
@@ -136,7 +137,7 @@ function validate_node(node, schema, all_nodes = {}) {
 
   const node_schema = schema[node.type];
 
-  for (const [prop_name, prop_def] of Object.entries(node_schema)) {
+  for (const [prop_name, prop_def] of Object.entries(node_schema.properties)) {
     const value = node[prop_name];
 
     // Check primitive types
@@ -177,7 +178,7 @@ function validate_node(node, schema, all_nodes = {}) {
 
 export default class Document {
   /** @type {Selection | undefined} */
-  selection = $state();
+  #selection = $state();
   config = $state();
   document_id = $state();
   nodes = $state();
@@ -190,6 +191,86 @@ export default class Document {
 
 	// Reactive variable for selected node
 	selected_node = $derived(this.get_selected_node());
+	layout_node = $derived(this.get_layout_node());
+	available_annotation_types = $derived(this.get_available_annotation_types());
+
+  /**
+   * Gets the current selection
+   * @returns {Selection | undefined}
+   */
+  get selection() {
+    return this.#selection;
+  }
+
+  /**
+   * Sets the selection with validation
+   * @param {Selection | undefined} value - The new selection
+   * @throws {Error} Throws if the selection is invalid
+   */
+  set selection(value) {
+    // if (value !== undefined) {
+    //   this._validate_selection(value);
+    // }
+    this.#selection = value;
+  }
+
+  /**
+   * Validates that a selection is within bounds and refers to valid paths.
+   *
+   * @param {Selection} selection - The selection to validate
+   * @throws {Error} Throws if the selection is invalid
+   * @private
+   */
+  _validate_selection(selection) {
+    if (!selection) return; // no selection is a valid selection
+    if (selection && !Array.isArray(selection.path)) {
+      throw new Error('Selection must have a valid path');
+    }
+
+    const selection_type = selection.type;
+    if (selection_type === 'node') {
+      // For node selections, path should point to a node_array
+      if (this.inspect(selection.path).type !== 'node_array') {
+        throw new Error(`Node selection path does not point to a node array: ${selection.path.join('.')}`);
+      }
+
+      const node_array = this.get(selection.path);
+
+      // Validate anchor_offset and focus_offset are within bounds
+      const max_offset = node_array.length;
+
+      if (selection.anchor_offset < 0 || selection.anchor_offset > max_offset) {
+        throw new Error(`Node selection anchor_offset ${selection.anchor_offset} is out of bounds (0-${max_offset})`);
+      }
+
+      if (selection.focus_offset < 0 || selection.focus_offset > max_offset) {
+        throw new Error(`Node selection focus_offset ${selection.focus_offset} is out of bounds (0-${max_offset})`);
+      }
+
+    } else if (selection_type === 'text') {
+      // For text selections, path should point to an annotated_text property
+      const annotated_text = this.get(selection.path);
+
+      // Validate anchor_offset and focus_offset are within text bounds
+      const char_length = get_char_length(annotated_text.text);
+
+      if (selection.anchor_offset < 0 || selection.anchor_offset > char_length) {
+        throw new Error(`Text selection anchor_offset ${selection.anchor_offset} is out of bounds (0-${char_length})`);
+      }
+
+      if (selection.focus_offset < 0 || selection.focus_offset > char_length) {
+        throw new Error(`Text selection focus_offset ${selection.focus_offset} is out of bounds (0-${char_length})`);
+      }
+    } else if (selection_type === 'property') {
+      // For property selections, just validate the path exists
+      if (!this.inspect(selection.path)) {
+        throw new Error(`Property selection path not found: ${selection.path.join('.')}`);
+      }
+
+    } else {
+      throw new Error(`Unknown selection type: ${selection_type}`);
+    }
+  }
 
   /**
    * @param {DocumentSchema} schema - The document schema
@@ -203,7 +284,6 @@ export default class Document {
     validate_document_schema(schema);
 
     this.schema = schema;
-    this.selection = selection;
     this.config = config;
     this.nodes = {};
 
@@ -216,6 +296,9 @@ export default class Document {
 
     // The last element in the serialized_doc is the document itself (the root node)
     this.document_id = serialized_doc.at(-1)?.id;
+
+    // Set selection after nodes are initialized so validation can work properly
+    this.selection = selection;
   }
 
   generate_id() {
@@ -226,6 +309,13 @@ export default class Document {
     }
   }
 
+ 	get_available_annotation_types() {
+    if (this.selection?.type !== 'text') return [];
+    const path = this.selection.path;
+    const property_definition = this.inspect(path);
+    return property_definition.node_types || [];
+	}
+
  	// Helper function to get the currently selected node
 	get_selected_node() {
 		if (!this.selection) return null;
@@ -240,13 +330,37 @@ export default class Document {
    		return node_id ? this.get(node_id) : null;
 		} else {
 		  // we are assuming we are either in a text or property (=custom) selection
-			const node_id = this.selection?.path?.slice(0, -1);
-			if (!node_id) return null;
-			const owner_node = this.get(node_id);
+			const owner_node_path = this.selection?.path?.slice(0, -1);
+			if (!owner_node_path) return null;
+			const owner_node = this.get(owner_node_path);
 			return owner_node;
 		}
 	}
 
+	// NOTE: This code is a bit whacky, but works for now.
+	// TODO: Refactor as we settle on a final API
+	get_layout_node() {
+    if (!this.selected_node) return null;
+
+    // The selected node already is a layout node
+    if (this.selected_node.layout) {
+      return this.selected_node;
+    }
+
+    // We resolve the parent node if available, and return it if it's a layout node.
+    // NOTE: We only support one level atm, we may want to implement this recursively
+    if (this.selection.type === 'node') {
+      const parent_node = this.get(this.selection.path.slice(0, -1));
+      return parent_node.layout ? parent_node : null;
+    } else {
+      // We are either in a text or property (=custom) selection
+      const parent_node_path = this.selection?.path?.slice(0, -3);
+			if (!parent_node_path) return null;
+			const parent_node = this.get(parent_node_path);
+      return parent_node.layout ? parent_node : null;
+    }
+	}
+
   // Internal unsafe function: Never call this directly
   _apply_op(op) {
     const [type, ...args] = op;
@@ -352,8 +466,8 @@ export default class Document {
    * doc.get(['page_1', 'body', 3, 'list_items', 0]) // => { type: 'list_item', id: 'list_item_1', ... }
    *
    * @example
-   * // Get an annotated string property
-   * doc.get(['page_1', 'cover', 'title']) // => ['Hello world', []]
+   * // Get an annotated text property
+   * doc.get(['page_1', 'cover', 'title']) // => {text: 'Hello world', annotations: []}
    */
   get(path) {
     if (typeof path === 'string') {
@@ -372,6 +486,9 @@ export default class Document {
         if (this.property_type(val.type, path_segment) === 'node_array') {
           val = val[path_segment]; // e.g. for the page body ['list_1', 'paragraph_1']
           val_type = 'node_array';
+        } else if (this.property_type(val.type, path_segment) === 'annotated_text') {
+          val = val[path_segment];
+          val_type = 'annotated_text';
         } else if (this.property_type(val.type, path_segment) === 'node') {
           val = this.nodes[val[path_segment]];
           val_type = 'node';
@@ -379,7 +496,7 @@ export default class Document {
           val = val[path_segment];
           val_type = 'value_array';
         } else {
-          // Resolve value properties sucha as string, integer, datetime
+          // Resolve value properties such as string, integer, datetime
           val = val[path_segment];
           val_type = 'value';
         }
@@ -390,6 +507,32 @@ export default class Document {
       } else if (val_type === 'value_array') {
         val = val[path_segment];
         val_type = 'value';
+      } else if (val_type === 'annotated_text') {
+        if (path_segment === 'text') {
+          val = val.text;
+          val_type = 'value';
+        } else if (path_segment === 'annotations') {
+          val = val.annotations;
+          val_type = 'annotation_array';
+        } else {
+          throw new Error(`Invalid path segment "${path_segment}" for annotated_text. Use "text" or "annotations".`);
+        }
+      } else if (val_type === 'annotation_array') {
+        val = val[path_segment];
+        val_type = 'annotation';
+      } else if (val_type === 'annotation') {
+        if (path_segment === 'node_id') {
+          val = this.nodes[val.node_id];
+          val_type = 'node';
+        } else if (path_segment === 'start_offset') {
+          val = val.start_offset;
+          val_type = 'value';
+        } else if (path_segment === 'end_offset') {
+          val = val.end_offset;
+          val_type = 'value';
+        } else {
+          throw new Error(`Invalid path segment "${path_segment}" for annotation. Use "start_offset", "end_offset", or "node_id".`);
+        }
       }
     }
     return val;
@@ -430,7 +573,7 @@ export default class Document {
         kind: 'property',
         name: property_name,
         // Merge property spec from schema
-        ...this.schema[parent.type][property_name]
+        ...this.schema[parent.type].properties[property_name]
       };
     } else {
       // Parent is a property (or we are at the root), so we are dealing with a node.
@@ -445,17 +588,54 @@ export default class Document {
   }
 
   /**
-   * Determines the kind of a node ('text' for pure text nodes or 'node' for anything else)
-   * NOTE: currently we assume a 'content' property for pure text nodes
+   * Determines the kind of a node ('block' for structured blocks, 'text' for pure
+   * text nodes or 'annotation' for annotation nodes.
    * @param {any} node
-   * @returns {'text'|'node'}
+   * @returns {NodeKind}
    */
   kind(node) {
-    if (['annotated_string', 'string'].includes(this.schema[node.type]?.content?.type)) {
-      return 'text'
-    } else {
-      return 'node';
+    return this.schema[node.type].kind;
+  }
+
+  /**
+   * Determines whether a node type can be inserted at a given selection.
+   * @param {string} node_type - The type of node to insert.
+   * @param {Selection} [selection] - The selection at which to insert the node.
+   * @returns {boolean} True if the node type can be inserted, false otherwise.
+   */
+  can_insert(node_type, selection = this.selection) {
+    if (selection?.type === 'node') {
+      const property_definition = this.inspect(selection.path);
+      if (property_definition.node_types.includes(node_type)) {
+        return true;
+      }
+    }
+
+    // No insert position found yet, and root not reached, try one level up if possible
+    let next_node_insert_cursor = this.get_next_node_insert_cursor(selection);
+    if (!next_node_insert_cursor) return false;
+    return this.can_insert(node_type, next_node_insert_cursor);
+  }
+
+  /**
+   * Compute next possible insert position from a given selection
+   *
+   * @param {Selection} [selection] - Reference selection
+   * @returns {Selection} True if the paste operation was successful, false otherwise
+   */
+  get_next_node_insert_cursor(selection = this.selection) {
+    // There's no parent path to insert into
+    if (!selection || selection.path.length <= 2) {
+      return null;
     }
+
+    const node_offset = parseInt(String(selection.path.at(-2)), 10) + 1;
+    return {
+      type: 'node',
+      path: selection.path.slice(0, -2),
+      anchor_offset: node_offset,
+      focus_offset: node_offset,
+    };
   }
 
   /**
@@ -469,30 +649,60 @@ export default class Document {
     if (this.selection?.type !== 'text') return null;
 
     const { start, end } = this.get_selection_range();
-    const annotated_string = this.get(this.selection.path);
-    const annotations = annotated_string[1];
+    const annotated_text = this.get(this.selection.path);
+    const annotations = annotated_text.annotations;
 
-    const active_annotation = annotations.find(([annotation_start, annotation_end]) =>
-      (annotation_start <= start && annotation_end > start) ||
-      (annotation_start < end && annotation_end >= end) ||
-      (annotation_start >= start && annotation_end <= end)
+    const active_annotation = annotations.find(({start_offset, end_offset}) =>
+      (start_offset <= start && end_offset > start) ||
+      (start_offset < end && end_offset >= end) ||
+      (start_offset >= start && end_offset <= end)
     ) || null;
 
-    if (annotation_type) {
-      return active_annotation?.[2] === annotation_type ? active_annotation : null;
+    if (annotation_type && active_annotation) {
+      const annotation_node = this.get(active_annotation?.node_id);
+      return annotation_node?.type === annotation_type ? active_annotation : null;
     } else {
       return active_annotation;
     }
   }
 
+  get_selected_annotated_text() {
+    if (this.selection?.type !== 'text') return null;
+
+    const selection_start =   Math.min(this.selection.anchor_offset, this.selection.focus_offset);
+    const selection_end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
+    const annotated_text = this.get(this.selection.path);
+    const text = char_slice(annotated_text.text, selection_start, selection_end);
+    const nodes = {};
+    const annotations = annotated_text.annotations.map(a => {
+      if (selection_start < a.end_offset && selection_end > a.start_offset) {
+        const sub_graph = this.traverse(a.node_id);
+        for (const node of sub_graph) {
+          if (!nodes[node.id]) {
+            nodes[node.id] = node;
+          }
+        }
+        return {
+          start_offset: Math.max(a.start_offset - selection_start, 0),
+          end_offset: Math.min(a.end_offset - selection_start, selection_end - selection_start),
+          node_id: a.node_id
+        };
+      } else {
+        return null;
+      }
+    }).filter(Boolean);
+
+    return { text, annotations, nodes };
+  }
+
   // TODO: think about ways how we can also turn a node selection into plain text.
   get_selected_plain_text() {
     if (this.selection?.type !== 'text') return null;
 
     const start =   Math.min(this.selection.anchor_offset, this.selection.focus_offset);
     const end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
-    const annotated_string = this.get(this.selection.path);
-    return char_slice(annotated_string[0], start, end);
+    const annotated_text = this.get(this.selection.path);
+    return char_slice(annotated_text.text, start, end);
   }
 
   get_selected_nodes() {
@@ -504,41 +714,6 @@ export default class Document {
     return $state.snapshot(node_array.slice(start, end));
   }
 
-  move_node_cursor(direction) {
-    if (this.selection?.type !== 'node') return;
-    const node_array = this.get(this.selection.path);
-
-    const { start, end } = this.get_selection_range();
-
-    if (this.selection.anchor_offset !== this.selection.focus_offset) {
-      // If selection is not collapsed, collapse it to the right or the left
-      if (direction === 'forward') {
-        this.selection.focus_offset = end;
-        this.selection.anchor_offset = end;
-      } else if (direction === 'backward') {
-        this.selection.focus_offset = start;
-        this.selection.anchor_offset = start;
-      }
-    } else if (direction === 'forward' && end < node_array.length) {
-      this.selection.focus_offset = end + 1;
-      this.selection.anchor_offset = end + 1;
-    } else if (direction === 'backward' && start > 0) {
-      this.selection.focus_offset = start - 1;
-      this.selection.anchor_offset = start - 1;
-    }
-  }
-
-  expand_node_selection(direction) {
-    if (this.selection.type !== 'node') return;
-    const node_array = this.get(this.selection.path);
-
-    if (direction === 'forward') {
-      this.selection.focus_offset = Math.min(this.selection.focus_offset + 1, node_array.length);
-    } else if (direction === 'backward') {
-      this.selection.focus_offset = Math.max(this.selection.focus_offset - 1, 0);
-    }
-  }
-
   select_parent() {
     if (!this.selection) return;
     if (['text', 'property'].includes(this.selection?.type)) {
@@ -595,33 +770,7 @@ export default class Document {
   // IMPORTANT: Leaf nodes must go first, branches second and the root node (entry point) last (depth-first traversal)
   // NOTE: Nodes that are not reachable from the entry point node will not be included in the serialization
   traverse(node_id) {
-    const json = [];
-    const visited = {};
-    const visit = (node) => {
-      if (!node || visited[node.id]) {
-        return;
-      }
-      visited[node.id] = true;
-      for (const [, value] of Object.entries(node)) {
-        // TODO: Use schema inspection and do this only for properties of type `node_array`
-        if (Array.isArray(value)) {
-          for (const v of value) {
-            if (typeof v === 'string') {
-              visit($state.snapshot(this.get(v)));
-            }
-          }
-        } else if (typeof value === 'string') {
-          // TODO: Use schema inspection and do this only for properties of type `ref`
-          visit($state.snapshot(this.get(value)));
-        }
-      }
-      // Finally add the node to the result.
-      // We use a deep clone, so we make sure nothing of the original document is referenced.
-      json.push(structuredClone(node));
-    }
-    // Start with the root node (document_id)
-    visit($state.snapshot(this.get(node_id)));
-    return json;
+    return traverse(node_id, this.schema, $state.snapshot(this.nodes));
   }
 
   /**
@@ -633,7 +782,7 @@ export default class Document {
   }
 
   // property_type('page', 'body') => 'node_array'
-  // property_type('paragraph', 'content') => 'annotated_string'
+  // property_type('paragraph', 'content') => 'annotated_text'
   property_type(type, property) {
     if (typeof type !== 'string') throw new Error(`Invalid type ${type} provided`);
     if (typeof property !== 'string') throw new Error(`Invalid property ${property} provided`);
@@ -642,9 +791,9 @@ export default class Document {
     if (property === 'id') return 'string';
 
     if (!this.schema[type]) throw new Error(`Type ${type} not found in schema`);
-    if (!this.schema[type][property]) throw new Error(`Property ${property} not found in type ${type}`);
+    if (!this.schema[type].properties[property]) throw new Error(`Property ${property} not found in type ${type}`);
 
-    return this.schema[type][property].type;
+    return this.schema[type].properties[property].type;
   }
 
   // Count how many times a node is referenced in the document