fix: #540 getUrl provides faulty, mangled Data URLs

Removes nativeContent from Scribe/_contentOps
Moves base64FromUnicode/unicodeFromBase64 => tools/base64.js
Renames tools/html5/urlEncode -> tools/html5/dataURI
Fixes Vrapper.test to use proper Media type for testing

Author: iridiankin

packages/engine/Vrapper/Vrapper.js

@@ -497,7 +497,7 @@ export default class Vrapper extends Cog {
 
 
   getTypeName (options: any) {
-    this.requireActive(options);
+    if (this.isResource()) this.requireActive(options);
     return this._typeName;
   }
 

packages/engine/Vrapper/Vrapper.test.js

@@ -44,10 +44,23 @@ const createAInstance
       instancePrototype: "test",
     }, });
 
+const createMedia = {
+  type: "TRANSACTED",
+  actions: [
+    created({ id: "theContent", typeName: "Blob" }),
+    created({ id: "theMedia", typeName: "Media", initialState: {
+      owner: "child",
+      name: "mediaName",
+      content: "theContent",
+    }, }),
+  ],
+};
+
 
 describe("Vrapper", () => {
   let harness: { createds: Object, engine: Object, prophet: Object, testEntities: Object };
   const testScriptPartitions = () => harness.createds.TestScriptyThing;
+  const medias = () => harness.createds.Media;
   const entities = () => harness.createds.Entity;
 
   const expectNoVrapper = rawId => { expect(harness.engine.tryVrapper(rawId)).toBeFalsy(); };
@@ -151,9 +164,9 @@ describe("Vrapper", () => {
 
     beforeEach(() => {
       harness = createEngineTestHarness({ debug: 0, claimBaseBlock: false }, [
-        transactionA, createAInstance,
+        transactionA, createAInstance, createMedia,
       ]);
-      testVrapper = testScriptPartitions().child;
+      testVrapper = medias().theMedia;
     });
 
     describe("_getMediaTypeFromTags", () => {

packages/prophet/Oracle/OraclePartitionConnection.js

@@ -72,7 +72,7 @@ export default class OraclePartitionConnection extends PartitionConnection {
     try {
       this.warnEvent(1, "\n\tBegun initializing connection with options", initialNarrateOptions,
           ...dumpObject(this));
-      const ret = _connect(this, initialNarrateOptions, onConnectData);
+      const ret = await _connect(this, initialNarrateOptions, onConnectData);
       this.warnEvent(1, "\n\tDone initializing connection with options", initialNarrateOptions,
           "\n\tinitial narration:", ret);
       return ret;

packages/prophet/Oracle/_mediaOps.js

@@ -37,7 +37,7 @@ export function _requestMediaContents (connection: OraclePartitionConnection,
         throw new Error(`OraclePartitionConnection has no authority connection specified ${
             ""} and could not locate local media URL from Scribe`);
       }
-      return authorityConnection.requestMediaContents([mediaInfo])[0];
+      return authorityConnection.getMediaURL(mediaInfo);
     }
     const retrieveMediaContent = connection.getRetrieveMediaContent();
     if (!retrieveMediaContent) {

packages/prophet/Scribe/Scribe.js

@@ -139,7 +139,7 @@ export default class Scribe extends Prophet {
     let alreadyWrapped;
     try {
       if (!bvobInfo) throw new Error(`Cannot find Bvob info '${bvobId}'`);
-      return _decodeBvobContent(this, bvobInfo, decoder, contextInfo, onError);
+      return _decodeBvobContent(this, bvobInfo, decoder, contextInfo, onError.bind(this));
     } catch (error) { throw onError.call(this, error); }
     function onError (error) {
       if (alreadyWrapped) return error;

packages/prophet/Scribe/ScribePartitionConnection.js

@@ -155,7 +155,7 @@ export default class ScribePartitionConnection extends PartitionConnection {
     return mediaInfos.map(mediaInfo => {
       try {
         const mediaEntry = this._getMediaEntry(mediaInfo.mediaId, !!mediaInfo.asURL);
-        if (mediaInfo.asURL) return _getMediaURL(this, mediaInfo, mediaEntry);
+        if (mediaInfo.asURL) return _getMediaURL(this, mediaInfo, mediaEntry, onError.bind(this));
         let actualInfo = mediaInfo;
         if (!actualInfo.bvobId) {
           if (!mediaEntry || !mediaEntry.mediaInfo) {
@@ -195,11 +195,27 @@ export default class ScribePartitionConnection extends PartitionConnection {
 
   prepareBvob (content: any, mediaInfo?: MediaInfo):
       { buffer: ArrayBuffer, contentId: string, persistProcess: ?Promise<any> } {
-    const { buffer, contentId } = bufferAndContentIdFromNative(content, mediaInfo);
-    return {
-      content, buffer, contentId,
-      persistProcess: this._prophet._persistBvobContent(buffer, contentId),
-    };
+    try {
+      const { buffer, contentId } = bufferAndContentIdFromNative(content, mediaInfo);
+      if (mediaInfo.bvobId && (!mediaInfo.bvobId !== contentId)) {
+        this.errorEvent(`\n\tINTERNAL ERROR: bvobId mismatch when preparing bvob for Media '${
+                mediaInfo.name}', CONTENT IS NOT PERSISTED`,
+            "\n\tactual content id:", contentId,
+            "\n\trequested bvobId:", mediaInfo.bvobId,
+            "\n\tmediaInfo:", ...dumpObject(mediaInfo),
+            "\n\tcontent:", ...dumpObject({ content }),
+        );
+        return {};
+      }
+      return {
+        content, buffer, contentId,
+        persistProcess: this._prophet._persistBvobContent(buffer, contentId),
+      };
+    } catch (error) {
+      throw this.wrapErrorEvent(error, `prepareBvob(${typeof content})`,
+          "\n\tcontent:", ...dumpObject({ content }),
+          "\n\tmediaInfo:", ...dumpObject(mediaInfo));
+    }
   }
 
   getMediaInfo (mediaId: VRef) {

packages/prophet/Scribe/_contentOps.js

@@ -6,7 +6,7 @@ import { VRef, getRawIdFrom } from "~/raem/ValaaReference";
 import type { MediaInfo, RetrieveMediaContent } from "~/prophet/api/Prophet";
 
 import { dumpObject, invariantifyString, thenChainEagerly, vdon } from "~/tools";
-import { encodeDataURI } from "~/tools/html5/urlEncode";
+import { encodeDataURI } from "~/tools/html5/dataURI";
 import type MediaDecoder from "~/tools/MediaDecoder";
 import { stringFromUTF8ArrayBuffer } from "~/tools/textEncoding";
 
@@ -26,7 +26,6 @@ export type MediaEntry = {
   mediaInfo: MediaInfo,
   isPersisted: boolean,
   isInMemory: boolean,
-  nativeContent?: any,
 };
 
 export type MediaLookup = {
@@ -45,7 +44,7 @@ export function _reprocessMedia (connection: ScribePartitionConnection, mediaEve
   let newEntry: MediaEntry;
   if (currentEntry) {
     mediaInfo = { ...currentEntry.mediaInfo };
-    newEntry = { ...currentEntry, mediaInfo, nativeContent: undefined };
+    newEntry = { ...currentEntry, mediaInfo };
   } else {
     if (mediaId.isInherited()) {
       mediaInfo = { ...connection._getMediaEntry(mediaId).mediaInfo };
@@ -84,18 +83,13 @@ export function _reprocessMedia (connection: ScribePartitionConnection, mediaEve
 
   const tryRetrieve = async () => {
     try {
-      if (mediaInfo.bvobId && connection._prophet.tryGetCachedBvobContent(mediaInfo.bvobId)) {
-        if (currentEntry && (currentEntry.mediaInfo.bvobId === mediaInfo.bvobId)) {
-          // content is in bvob buffer cache with equal bvobId. Reuse.
-          newEntry.nativeContent = currentEntry.nativeContent;
-        }
-      } else if (mediaInfo.bvobId || mediaInfo.sourceURL) {
+      if (mediaInfo.bvobId && !connection._prophet.tryGetCachedBvobContent(mediaInfo.bvobId)) {
         // TODO(iridian): Determine whether media content should be pre-cached or not.
-        const content = await retrieveMediaContent(mediaId, mediaInfo);
+        const content = await retrieveMediaContent(mediaId, { ...mediaInfo,
+          type: "application", subtype: "octet-stream", mime: "application/octet-stream",
+        });
         if (typeof content !== "undefined") {
-          newEntry.nativeContent = content;
-          const { persistProcess } = connection.prepareBvob(newEntry.nativeContent, mediaInfo);
-          await persistProcess;
+          await connection.prepareBvob(content, mediaInfo).persistProcess;
         }
       }
       // Delays actual media info content update into a finalizer function so that recordTruth
@@ -177,39 +171,30 @@ export function _decodeBvobContent (scribe: Scribe, bvobInfo: BvobInfo,
       }
       return decodedContent;
     },
-  ], onError.bind(scribe));
+  ], onError);
 }
 
 export function _getMediaURL (connection: ScribePartitionConnection, mediaInfo: MediaInfo,
-    mediaEntry: MediaEntry): any {
-  let nativeContent;
+    mediaEntry: MediaEntry, onError: Function): any {
   // Only use cached in-memory nativeContent if its id matches the requested id.
-  if ((!mediaInfo || !mediaInfo.bvobId || (mediaInfo.bvobId === mediaEntry.mediaInfo.bvobId))
-      && (typeof mediaEntry.nativeContent !== "undefined")) {
-    nativeContent = mediaEntry.nativeContent;
-  } else {
-    const bvobId = (mediaInfo && mediaInfo.bvobId) || mediaEntry.mediaInfo.bvobId;
-    if (!bvobId) return undefined;
-    const bufferCandidate = connection._prophet.tryGetCachedBvobContent(bvobId);
-    nativeContent = bufferCandidate &&
-        _nativeObjectFromBufferAndMediaInfo(bufferCandidate, mediaInfo || mediaEntry.mediaInfo);
-    if (bvobId === mediaEntry.mediaInfo.bvobId) {
-      mediaEntry.nativeContent = nativeContent;
-    }
+  const bvobId = (mediaInfo && mediaInfo.bvobId) || mediaEntry.mediaInfo.bvobId;
+  const bvobInfo = connection._prophet._bvobLookup[bvobId || ""];
+  // Media's with sourceURL or too large/missing bvobs will be handled by Oracle
+  if (!bvobInfo || !(bvobInfo.byteLength <= 10000)) return undefined;
   }
-  if ((typeof nativeContent === "string") && nativeContent.length < 10000) {
-    // TODO(iridian): Is there a use case to create data URI's for json types?
-    const { type, subtype } = mediaInfo || mediaEntry.mediaInfo;
-    return encodeDataURI(nativeContent, type, subtype);
-  }
-  // TODO(iridian): With systems that support Service Workers we return URL's which the service
-  // workers recognize and can redirect to 'smooth' IndexedDB accesses, see
+  // TODO(iridian): With systems that support Service Workers we will eventually return URL's which
+  // the service workers recognize and can redirect to 'smooth' IndexedDB accesses, see
   // https://gist.github.com/inexorabletash/687e7c5914049536f5a3
   // ( https://www.google.com/search?q=url+to+indexeddb )
   // Otherwise IndexedDB can't be accessed by the web pages directly, but horrible hacks must be
   // used like so:
   // https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB
-  return undefined;
+  return thenChainEagerly(connection._prophet.readBvobContent(bvobInfo.bvobId),
+      (buffer => {
+        const { type, subtype } = mediaInfo || mediaEntry.mediaInfo;
+        return encodeDataURI(buffer, type, subtype);
+      })
+      , onError);
 }
 
 // Returns the requested media content immediately as a native object if it is in in-memory cache.
@@ -218,24 +203,10 @@ export function _getMediaURL (connection: ScribePartitionConnection, mediaInfo:
 // Otherwise throws an error.
 export function _readMediaContent (connection: ScribePartitionConnection, mediaInfo: MediaInfo,
     mediaEntry: MediaEntry, onError: Function): any {
-  // Only return cached in-memory nativeContent if its id matches the requested id.
   const bvobId = mediaInfo.bvobId;
-  if (mediaEntry && (typeof mediaEntry.nativeContent !== "undefined")
-      && (!bvobId || (bvobId === mediaEntry.mediaInfo.bvobId))) {
-    return mediaEntry.nativeContent;
-  }
   if (!bvobId) return undefined;
-  return thenChainEagerly(
-      connection._prophet.readBvobContent(bvobId),
-      (buffer) => {
-        if (!buffer) return undefined;
-        // nativeContent should go in favor of bvobInfo decoded contents
-        const nativeContent = _nativeObjectFromBufferAndMediaInfo(buffer, mediaInfo);
-        if (mediaEntry && (bvobId === mediaEntry.mediaInfo.bvobId)) {
-          mediaEntry.nativeContent = nativeContent;
-        }
-        return nativeContent;
-      },
+  return thenChainEagerly(connection._prophet.readBvobContent(bvobId),
+      (buffer) => (!buffer ? undefined : _nativeObjectFromBufferAndMediaInfo(buffer, mediaInfo)),
       onError);
 }
 

packages/prophet/Scribe/_databaseOps.js

@@ -146,13 +146,18 @@ export function _readMediaInfos (connection: ScribePartitionConnection, results:
             resolve();
             return;
           }
-          const thisMediaInfo = { ...cursor.value, isInMemory: true };
-          if (thisMediaInfo.mediaInfo && thisMediaInfo.mediaInfo.bvobId
-              && thisMediaInfo.isInMemory) {
-            connection._prophet._addContentInMemoryReference(thisMediaInfo.mediaInfo);
+          const entry = { ...cursor.value, isInMemory: true };
+          if (entry.mediaInfo && entry.mediaInfo.bvobId && entry.isInMemory) {
+            if (!connection._prophet._bvobLookup[entry.mediaInfo.bvobId]) {
+              connection.errorEvent(`Can't find Media "${entry.mediaInfo.name
+                  }" in-memory Bvob info for ${entry.mediaInfo.bvobId
+                  } when reading partition media infos`);
+            } else {
+              connection._prophet._addContentInMemoryReference(entry.mediaInfo);
+            }
           }
-          results[cursor.key] = thisMediaInfo;
-          cursor.update(thisMediaInfo);
+          results[cursor.key] = entry;
+          cursor.update(entry);
           cursor.continue();
         };
         req.onerror = (evt) => reject(new Error(evt.target.error.message));

packages/prophet/api/PartitionConnection.js

@@ -162,7 +162,7 @@ export default class PartitionConnection extends LogEventGenerator {
     delete mediaInfo.mime;
     delete mediaInfo.type;
     delete mediaInfo.subtype;
-    return this.requestMediaContents([mediaInfo])[0];
+    return thenChainEagerly(this.requestMediaContents([mediaInfo]), results => results[0]);
   }
 
   /**
@@ -205,7 +205,7 @@ export default class PartitionConnection extends LogEventGenerator {
     return thenChainEagerly(this.requestMediaContents([mediaInfo]), results => results[0]);
   }
 
-  requestMediaContents (mediaInfos: MediaInfo[]) {
+  requestMediaContents (mediaInfos: MediaInfo[]): Promise<(Promise | any)[]> | (Promise | any)[] {
     return this._upstreamConnection.requestMediaContents(mediaInfos);
   }
 

packages/tools/base64.js

@@ -3,6 +3,18 @@
 import { TextEncoder, TextDecoder } from "text-encoding";
 import base64js from "base64-js";
 
+export function base64FromUnicode (unicodeString: string) {
+  return btoa(encodeURIComponent(unicodeString).replace(/%([0-9A-F]{2})/g,
+    (match: any, p1: any) => String.fromCharCode(parseInt(p1, 16))
+  ));
+}
+
+export function unicodeFromBase64 (base64String: string) {
+  return decodeURIComponent(atob(base64String).split("").map(
+    (c) => `%${`${"00"}${c.charCodeAt(0).toString(16)}`.slice(-2)}`
+  ).join(""));
+}
+
 export function base64FromArrayBuffer (data: ArrayBuffer) {
   return base64js.fromByteArray(new Uint8Array(data));
 }