@fluidframework/odsp-driver 1.2.7 → 2.0.0-dev.1.3.0.96595

package/src/odspUtils.ts

@@ -13,7 +13,7 @@ import {
     NetworkErrorBasic,
 } from "@fluidframework/driver-utils";
 import { assert, performance } from "@fluidframework/common-utils";
-import { ChildLogger, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
+import { ChildLogger, PerformanceEvent, TelemetryDataTag, wrapError } from "@fluidframework/telemetry-utils";
 import {
     fetchIncorrectResponse,
     throwOdspNetworkError,
@@ -27,6 +27,7 @@ import {
     isTokenFromCache,
     OdspResourceTokenFetchOptions,
     ShareLinkTypes,
+    ISharingLinkKind,
     TokenFetcher,
     ICacheEntry,
     snapshotKey,
@@ -123,7 +124,8 @@ export async function fetchHelper(
     }, (error) => {
         const online = isOnline();
         const errorText = `${error}`;
-
+        const urlRegex = /((http|https):\/\/(\S*))/i;
+        const redactedErrorText = errorText.replace(urlRegex, "REDACTED_URL");
         // This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
         if (error.name === "AbortError") {
             throw new RetryableError(
@@ -135,21 +137,30 @@ export async function fetchHelper(
                 "Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout, { driverVersion });
         }
 
-        //
         // WARNING: Do not log error object itself or any of its properties!
         // It could contain PII, like URI in message itself, or token in properties.
         // It is also non-serializable object due to circular references.
-        //
+        // eslint-disable-next-line unicorn/prefer-ternary
         if (online === OnlineStatus.Offline) {
             throw new RetryableError(
                 // pre-0.58 error message prefix: Offline
-                `ODSP fetch failure (Offline): ${errorText}`, DriverErrorType.offlineError, { driverVersion });
+                `ODSP fetch failure (Offline): ${redactedErrorText}`,
+                DriverErrorType.offlineError,
+                {
+                    driverVersion,
+                    rawErrorMessage: { value: errorText, tag: TelemetryDataTag.UserData },
+                });
         } else {
             // It is perhaps still possible that this is due to being offline, the error does not reveal enough
             // information to conclude.  Could also be DNS errors, malformed fetch request, CSP violation, etc.
             throw new RetryableError(
                 // pre-0.58 error message prefix: Fetch error
-                `ODSP fetch failure: ${errorText}`, DriverErrorType.fetchFailure, { driverVersion });
+                `ODSP fetch failure: ${redactedErrorText}`,
+                DriverErrorType.fetchFailure,
+                {
+                    driverVersion,
+                    rawErrorMessage: { value: errorText, tag: TelemetryDataTag.UserData },
+                });
         }
     });
 }
@@ -222,8 +233,10 @@ export interface INewFileInfo {
      * application can request creation of a share link along with the creation of a new file
      * by passing in an optional param to specify the kind of sharing link
      * (at the time of adding this comment Sept/2021), odsp only supports csl
+     * ShareLinkTypes will deprecated in future. Use ISharingLinkKind instead which specifies both
+     * share link type and the role type.
      */
-    createLinkType?: ShareLinkTypes;
+    createLinkType?: ShareLinkTypes | ISharingLinkKind;
 }
 
 export function getOdspResolvedUrl(resolvedUrl: IResolvedUrl): IOdspResolvedUrl {
@@ -337,3 +350,23 @@ export function createCacheSnapshotKey(odspResolvedUrl: IOdspResolvedUrl): ICach
 // 80KB is the max body size that we can put in ump post body for server to be able to accept it.
 // Keeping it 78KB to be a little cautious. As per the telemetry 99p is less than 78KB.
 export const maxUmpPostBodySize = 79872;
+
+/**
+ * Build request parameters to request for the creation of a sharing link along with the creation of the file
+ * through the /snapshot api call.
+ * @param shareLinkType - Kind of sharing link requested
+ * @returns A string of request parameters that can be concatenated with the base URI
+ */
+export function buildOdspShareLinkReqParams(shareLinkType: ShareLinkTypes | ISharingLinkKind | undefined) {
+    if (!shareLinkType) {
+        return;
+    }
+    const scope = (shareLinkType as ISharingLinkKind).scope;
+    if (!scope) {
+        return `createLinkType=${shareLinkType}`;
+    }
+    let shareLinkRequestParams = `createLinkScope=${scope}`;
+    const role = (shareLinkType as ISharingLinkKind).role;
+    shareLinkRequestParams = role ? `${shareLinkRequestParams}&createLinkRole=${role}` : shareLinkRequestParams;
+    return shareLinkRequestParams;
+}

package/src/opsCaching.ts

@@ -40,8 +40,9 @@ export class OpsCache {
     private readonly timerGranularity,
     private totalOpsToCache,
   ) {
-        /** initial batch is a special case because it will never be full - all ops prior (inclusive) to
-         *  startingSequenceNumber are never going to show up (undefined)
+        /**
+         * Initial batch is a special case because it will never be full - all ops prior (inclusive) to
+         * `startingSequenceNumber` are never going to show up (undefined)
          */
         const remainingSlots = this.batchSize - this.getPositionInBatchArray(startingSequenceNumber) - 1;
         if (remainingSlots !== 0) {

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "1.2.7";
+export const pkgVersion = "2.0.0-dev.1.3.0.96595";

package/src/prefetchLatestSnapshot.ts

@@ -28,19 +28,21 @@ import { IVersionedValueWithEpoch } from "./contracts";
 /**
  * Function to prefetch the snapshot and cached it in the persistant cache, so that when the container is loaded
  * the cached latest snapshot could be used and removes the network call from the critical path.
+ *
  * @param resolvedUrl - Resolved url to fetch the snapshot.
  * @param getStorageToken - function that can provide the storage token for a given site. This is
- *  is also referred to as the "VROOM" token in SPO.
+ * is also referred to as the "VROOM" token in SPO.
  * @param persistedCache - Cache to store the fetched snapshot.
  * @param forceAccessTokenViaAuthorizationHeader - whether to force passing given token via authorization header.
  * @param logger - Logger to have telemetry events.
  * @param hostSnapshotFetchOptions - Options to fetch the snapshot if any. Otherwise default will be used.
  * @param enableRedeemFallback - True to have the sharing link redeem fallback in case the Trees Latest/Redeem
- *  1RT call fails with redeem error. During fallback it will first redeem the sharing link and then make
- *  the Trees latest call.
- *  @deprecated - This will be replaced with snapshotFormatFetchType.
+ * 1RT call fails with redeem error. During fallback it will first redeem the sharing link and then make
+ * the Trees latest call.
+ * Note: this can be considered deprecated - it will be replaced with `snapshotFormatFetchType`.
  * @param fetchBinarySnapshotFormat - Control if we want to fetch binary format snapshot.
  * @param snapshotFormatFetchType - Snapshot format to fetch.
+ *
  * @returns - True if the snapshot is cached, false otherwise.
  */
 export async function prefetchLatestSnapshot(

package/src/retryUtils.ts

@@ -5,7 +5,7 @@
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { delay, performance } from "@fluidframework/common-utils";
-import { canRetryOnError } from "@fluidframework/driver-utils";
+import { canRetryOnError, getRetryDelayFromError } from "@fluidframework/driver-utils";
 import { OdspErrorType } from "@fluidframework/odsp-driver-definitions";
 import { Odsp409Error } from "./epochTracker";
 
@@ -43,8 +43,10 @@ export async function runWithRetry<T>(
 
             const coherencyError = error?.[Odsp409Error] === true;
             const serviceReadonlyError = error?.errorType === OdspErrorType.serviceReadOnly;
-            // Retry for retriable 409 coherency errors or serviceReadOnly errors.
-            if (!(coherencyError || serviceReadonlyError || canRetry)) {
+            // Retry for retriable 409 coherency errors or serviceReadOnly errors. These errors are always retriable
+            // unless someone specifically set canRetry = false on the error like in fetchSnapshot() flow. So in
+            // that case don't retry.
+            if (!((coherencyError || serviceReadonlyError) && canRetry)) {
                 throw error;
             }
 
@@ -54,8 +56,8 @@ export async function runWithRetry<T>(
             if (attempts === 5) {
                 logger.sendErrorEvent(
                     {
-                        eventName: coherencyError ?
-                            "CoherencyErrorTooManyRetries" : "ServiceReadonlyErrorTooManyRetries",
+                        eventName: coherencyError ? "CoherencyErrorTooManyRetries" :
+                            "ServiceReadonlyErrorTooManyRetries",
                         callName,
                         attempts,
                         duration: performance.now() - start, // record total wait time.
@@ -66,6 +68,7 @@ export async function runWithRetry<T>(
                 throw error;
             }
 
+            retryAfter = getRetryDelayFromError(error) ?? retryAfter;
             await delay(Math.floor(retryAfter));
             retryAfter += retryAfter / 4 * (1 + Math.random());
             lastError = error;

package/src/zipItDataRepresentationUtils.ts

@@ -8,7 +8,8 @@
  * https://microsoft.sharepoint-df.com/:w:/t/ODSPFileStore/ER06b64K_XdDjEyAKl-UT60BJiId39SCVkYSyo_2pvH9gQ?e=KYQ0c5
 */
 
-import { assert, IsoBuffer, Uint8ArrayToArrayBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
+import { assert, Uint8ArrayToArrayBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { NonRetryableError } from "@fluidframework/driver-utils";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { ReadBuffer } from "./ReadBufferUtils";
@@ -111,19 +112,11 @@ export function getValueSafely(map: { [index: number]: number; }, key: number) {
     return val;
 }
 
-export function getAndValidateNodeProps(node: NodeCore, props: string[], enforceAllProps = true) {
-    const propSet = new Set(props);
+export function getNodeProps(node: NodeCore) {
     const res: Record<string, NodeTypes> = {};
     for (const [keyNode, valueNode] of node.iteratePairs()) {
-        assertBlobCoreInstance(keyNode, "keynode should be a blob");
-        const keyStr = keyNode.toString();
-        if (propSet.has(keyStr)) {
-            propSet.delete(keyStr);
-            res[keyStr] = valueNode;
-        }
-    }
-    if (enforceAllProps) {
-        assert(propSet.size === 0, 0x288 /* All properties should exist */);
+        const id = getStringInstance(keyNode, "keynode should be a string");
+        res[id] = valueNode;
     }
     return res;
 }
@@ -159,20 +152,12 @@ export function iterate<T>(obj: { [Symbol.iterator]: () => IterableIterator<T>;
  */
 export abstract class BlobCore {
     public abstract get buffer(): Uint8Array;
-    public get arrayBuffer(): ArrayBufferLike {
-        return Uint8ArrayToArrayBuffer(this.buffer);
-    }
+    public abstract get arrayBuffer(): ArrayBufferLike;
 
     /**
      * Represents a blob.
-     * @param constString - Whether it contains const string declaration.
-     * @param useUtf8Code - Represents if the utf8 string marker code should be used when representing.
      */
-    constructor(public readonly constString: boolean, public readonly useUtf8Code: boolean = false) {}
-
-    public toString() {
-        return Uint8ArrayToString(this.buffer, "utf-8");
-    }
+    constructor() {}
 }
 
 /**
@@ -184,24 +169,26 @@ class BlobDeepCopy extends BlobCore {
     /**
      * Represents a deep copy of the blob.
      * @param data - Data array of the blob
-     * @param constString - Whether it contains const string declaration.
-     * @param useUtf8Code - Represents if the utf8 string marker code should be used when representing.
      */
-    constructor(protected readonly data: Uint8Array, constString: boolean, useUtf8Code: boolean = false) {
-        super(constString, useUtf8Code);
+    constructor(protected readonly data: Uint8Array) {
+        super();
     }
 
     public get buffer() {
         return this.data;
     }
 
-    public static read(buffer: ReadBuffer, lengthLen: number, constString: boolean): BlobCore {
+    public get arrayBuffer(): ArrayBufferLike {
+        return Uint8ArrayToArrayBuffer(this.buffer);
+    }
+
+    public static read(buffer: ReadBuffer, lengthLen: number): BlobCore {
         const length = buffer.read(lengthLen);
         const data = new Uint8Array(length);
         for (let counter = 0; counter < length; counter++) {
             data[counter] = buffer.read();
         }
-        return new BlobDeepCopy(data, constString);
+        return new BlobDeepCopy(data);
     }
 }
 
@@ -215,40 +202,60 @@ class BlobDeepCopy extends BlobCore {
      * @param data - Data array of the blob
      * @param start - Start point of the blob in the buffer.
      * @param end - End point of the blob in the buffer.
-     * @param constString - Whether it contains const string declaration.
      */
     constructor(
-        protected data: ReadBuffer,
+        protected data: Uint8Array,
         protected start: number,
         protected end: number,
-        constString: boolean,
     ) {
-        super(constString);
+        super();
     }
 
     public get buffer() {
-        return this.data.buffer.subarray(this.start, this.end);
+        return this.data.subarray(this.start, this.end);
+    }
+
+    // Equivalent to Uint8ArrayToArrayBuffer(this.buffer)
+    public get arrayBuffer(): ArrayBufferLike {
+        const offset = this.data.byteOffset;
+        return this.data.buffer.slice(this.start + offset, this.end + offset);
     }
 
-    public static read(buffer: ReadBuffer, lengthLen: number, constString: boolean): BlobCore {
+    public static read(buffer: ReadBuffer, lengthLen: number): BlobCore {
         const length = buffer.read(lengthLen);
         const pos = buffer.pos;
         buffer.skip(length);
-        return new BlobShallowCopy(buffer, pos, pos + length, constString);
+        return new BlobShallowCopy(buffer.buffer, pos, pos + length);
     }
 }
 
 export const addStringProperty =
-    (node: NodeCore, a: string, b: string, encodeValAsConstString: boolean = false) => {
-        node.addString(a, true); node.addString(b, encodeValAsConstString);
+    (node: NodeCore, a: string, b: string) => {
+        node.addDictionaryString(a); node.addString(b);
+    };
+export const addDictionaryStringProperty =
+    (node: NodeCore, a: string, b: string) => {
+        node.addDictionaryString(a); node.addString(b);
     };
 export const addNumberProperty = (node: NodeCore, a: string, b: number) => {
-    node.addString(a, true); node.addNumber(b);
+    node.addDictionaryString(a); node.addNumber(b);
 };
 export const addBoolProperty = (node: NodeCore, a: string, b: boolean) => {
-    node.addString(a, true); node.addBool(b);
+    node.addDictionaryString(a); node.addBool(b);
 };
 
+export interface IStringElement {
+    content: string;
+    dictionary: boolean;
+    _stringElement: true;
+}
+
+export interface IStringElementInternal extends Omit<IStringElement, "content"> {
+    content?: string;
+    startPos: number;
+    endPos: number;
+}
+
 /**
  * Three leaf types supported by tree:
  * 1. Node (sub-tree)
@@ -256,7 +263,7 @@ export const addBoolProperty = (node: NodeCore, a: string, b: boolean) => {
  * 3. integer
  * 4. boolean
  */
-export type NodeTypes = NodeCore | BlobCore | number | boolean;
+export type NodeTypes = NodeCore | BlobCore | number | boolean | IStringElement;
 
 export type NodeCoreTypes = "list" | "set";
 
@@ -287,8 +294,12 @@ export class NodeCore {
 
     public getString(index: number): string {
         const node = this.children[index];
-        assertBlobCoreInstance(node, "getString should return stringblob");
-        return node.toString();
+        return getStringInstance(node, "getString should return string");
+    }
+
+    public getMaybeString(index: number) {
+        const node = this.children[index];
+        return getMaybeStringInstance(node);
     }
 
     public getBlob(index: number): BlobCore {
@@ -321,12 +332,24 @@ export class NodeCore {
         return node;
     }
 
-    public addBlob(blob: Uint8Array, constString: boolean, useUtf8Code: boolean = false) {
-        this.children.push(new BlobDeepCopy(blob, constString, useUtf8Code));
+    public addBlob(blob: Uint8Array) {
+        this.children.push(new BlobDeepCopy(blob));
+    }
+
+    public addDictionaryString(payload: string) {
+        this.children.push({
+            content: payload,
+            dictionary: true,
+            _stringElement: true,
+        });
     }
 
-    public addString(payload: string, constString: boolean) {
-        this.addBlob(IsoBuffer.from(payload, "utf-8"), constString, true);
+    public addString(payload: string) {
+        this.children.push({
+            content: payload,
+            dictionary: false,
+            _stringElement: true,
+        });
     }
 
     public addNumber(payload: number | undefined) {
@@ -339,59 +362,91 @@ export class NodeCore {
         this.children.push(payload);
     }
 
+    // Can we do more efficiently here, without extra objects somehow??
+    private static readString(buffer: ReadBuffer, code: number, dictionary: boolean) {
+        const lengthLen = getValueSafely(codeToBytesMap, code);
+        const length = buffer.read(lengthLen);
+        const startPos = buffer.pos;
+        buffer.skip(length);
+        const result: IStringElementInternal = {
+            // Note: Setting here property 'content: undefined' makes code substantially slower!
+            dictionary,
+            _stringElement: true,
+            startPos,
+            endPos: buffer.pos,
+        };
+
+        // We are lying here in terms of presence of `content` property.
+        // This will be addressed at the bottom of NodeCore.load() by resolving all strings at once!
+        // It's equivalent (but much slower!) to do it here via
+        // result.content = Uint8ArrayToString(buffer.buffer.subarray(startPos, buffer.pos), "utf-8");
+        return result as IStringElementInternal & IStringElement;
+    }
+
     /**
      * Load and parse the buffer into a tree.
      * @param buffer - buffer to read from.
      */
-    protected load(buffer: ReadBuffer, dictionary: BlobCore[]) {
+    protected load(buffer: ReadBuffer, logger: ITelemetryLogger) {
+        const stack: NodeTypes[][] = [];
+        const stringsToResolve: IStringElementInternal[] = [];
+        const dictionary: IStringElement[] = [];
+
+        let children = this.children;
         for (;!buffer.eof;) {
-            let childValue: NodeTypes | undefined;
             const code = buffer.read();
             switch (code) {
                 case MarkerCodesStart.list:
                 case MarkerCodesStart.set: {
-                    childValue = new NodeCore(code === MarkerCodesStart.set ? "set" : "list");
-                    this.children.push(childValue);
-                    childValue.load(buffer, dictionary);
-                    break;
+                    const childValue = new NodeCore(code === MarkerCodesStart.set ? "set" : "list");
+                    children.push(childValue);
+                    stack.push(children);
+                    children = childValue.children;
+                    continue;
                 }
                 case MarkerCodes.ConstStringDeclare:
                 case MarkerCodes.ConstStringDeclareBig:
                 {
                     const stringId = buffer.read(getValueSafely(codeToBytesMap, code));
-                    const constString = BlobShallowCopy.read(buffer, getValueSafely(codeToBytesMap, code), true);
+                    const constString = NodeCore.readString(buffer, code, true /* dictionary */);
+                    stringsToResolve.push(constString);
                     dictionary[stringId] = constString;
-                    break;
+                    continue;
                 }
                 case MarkerCodes.ConstString8Id:
                 case MarkerCodes.ConstString16Id:
                 case MarkerCodes.ConstString32Id:
                 {
                     const stringId = buffer.read(getValueSafely(codeToBytesMap, code));
-                    childValue = dictionary[stringId];
-                    this.children.push(childValue);
-                    break;
+                    const content = dictionary[stringId];
+                    assert(content !== undefined, 0x3de /* const string not found */);
+                    children.push(content);
+                    continue;
                 }
                 case MarkerCodes.StringEmpty:
                 case MarkerCodes.String8Length:
                 case MarkerCodes.String16Length:
                 case MarkerCodes.String32Length:
+                {
+                    const str = NodeCore.readString(buffer, code, false /* dictionary */);
+                    stringsToResolve.push(str);
+                    children.push(str);
+                    continue;
+                }
                 case MarkerCodes.BinaryEmpty:
                 case MarkerCodes.BinarySingle8:
                 case MarkerCodes.BinarySingle16:
                 case MarkerCodes.BinarySingle32:
                 case MarkerCodes.BinarySingle64:
                 {
-                    childValue = BlobShallowCopy.read(buffer, getValueSafely(codeToBytesMap, code), false);
-                    this.children.push(childValue);
-                    break;
+                    children.push(BlobShallowCopy.read(buffer, getValueSafely(codeToBytesMap, code)));
+                    continue;
                 }
                 // If integer is 0.
                 case MarkerCodes.Int0:
                 {
-                    childValue = 0;
-                    this.children.push(childValue);
-                    break;
+                    children.push(0);
+                    continue;
                 }
                 case MarkerCodes.UInt8:
                 case MarkerCodes.UInt16:
@@ -402,23 +457,72 @@ export class NodeCore {
                 case MarkerCodes.Int32:
                 case MarkerCodes.Int64:
                 {
-                    childValue = buffer.read(getValueSafely(codeToBytesMap, code));
-                    this.children.push(childValue);
-                    break;
+                    children.push(buffer.read(getValueSafely(codeToBytesMap, code)));
+                    continue;
                 }
                 case MarkerCodes.BoolTrue:
-                    this.children.push(true);
-                    break;
+                    children.push(true);
+                    continue;
                 case MarkerCodes.BoolFalse:
-                    this.children.push(false);
-                    break;
+                    children.push(false);
+                    continue;
                 case MarkerCodesEnd.list:
                 case MarkerCodesEnd.set:
-                    return;
+                    // Note: We are not checking that end marker matches start marker.
+                    // I.e. that we do not have a case where we start a 'list' but end with a 'set'
+                    // Checking it would require more state tracking that seems not very useful, given
+                    // our code does not care.
+                    children = stack.pop()!;
+
+                    // To my surprise, checking children !== undefined adds measurable cost!
+                    // We will rely on children.push() crashing in case of mismatch, and check below
+                    // (outside of the loop)
+                    continue;
                 default:
                     throw new Error(`Invalid code: ${code}`);
             }
         }
+
+        // This also ensures that stack.length === 0.
+        assert(children === this.children, 0x3e7 /* Unpaired start/end list/set markers! */);
+
+        /**
+         * Process all the strings at once!
+         */
+        let length = 0;
+        for (const el of stringsToResolve) {
+            length += el.endPos - el.startPos + 1;
+        }
+        const stringBuffer = new Uint8Array(length);
+
+        length = 0;
+        const input = buffer.buffer;
+        assert(input.byteOffset === 0, 0x3e8 /* code below assumes no offset */);
+
+        for (const el of stringsToResolve) {
+            for (let it = el.startPos; it < el.endPos; it++) {
+                stringBuffer[length] = input[it];
+                length++;
+            }
+            stringBuffer[length] = 0;
+            length++;
+        }
+
+        if (length === stringBuffer.length) {
+            // All is good, we expect all the cases to get here
+            const result = Uint8ArrayToString(stringBuffer, "utf-8").split(String.fromCharCode(0));
+            assert(result.length === stringsToResolve.length + 1, 0x3e9 /* String content has \0 chars! */);
+            for (let i = 0; i < stringsToResolve.length; i++) {
+                stringsToResolve[i].content = result[i];
+            }
+        } else {
+            // Recovery code
+            logger.sendErrorEvent({ eventName: "StringParsingError" });
+            for (const el of stringsToResolve) {
+                assert(el.content === Uint8ArrayToString(input.subarray(el.startPos, el.endPos), "utf-8"),
+                    0x3ea /* test */);
+            }
+        }
     }
 }
 
@@ -427,15 +531,32 @@ export class NodeCore {
   * Provides loading and serialization capabilities.
   */
 export class TreeBuilder extends NodeCore {
-    static load(buffer: ReadBuffer): TreeBuilder {
+    static load(buffer: ReadBuffer, logger: ITelemetryLogger): TreeBuilder {
         const builder = new TreeBuilder();
-        const dictionary = new Array<BlobCore>();
-        builder.load(buffer, dictionary);
+        builder.load(buffer, logger);
         assert(buffer.eof, 0x233 /* "Unexpected data at the end of buffer" */);
         return builder;
     }
 }
 
+export function getMaybeStringInstance(node: NodeTypes): string | undefined {
+    const maybeString = node as IStringElement;
+    if (maybeString._stringElement) {
+        return maybeString.content;
+    }
+}
+
+export function getStringInstance(
+    node: NodeTypes,
+    message: string,
+): string {
+    const maybeString = node as IStringElement;
+    if (maybeString._stringElement) {
+        return maybeString.content;
+    }
+    throwBufferParseException(node, "BlobCore", message);
+}
+
 export function assertBlobCoreInstance(
     node: NodeTypes,
     message: string,
@@ -500,8 +621,10 @@ function getNodeType(value: NodeTypes): NodeType {
         return "NodeCore";
     } else if (typeof value === "boolean") {
         return "Boolean";
+    } else if (value._stringElement) {
+        return "String";
     }
     return "UnknownType";
 }
 
-type NodeType = "Number" | "BlobCore" | "NodeCore" | "Boolean" | "UnknownType";
+type NodeType = "Number" | "BlobCore" | "NodeCore" | "Boolean" | "UnknownType" | "String";