Fix bugs with the modularization

Add a test to ensure that the modularization works correctly.
Since we are doing our own modularization rather than relying upon emcc, we have to do a workaround to undo its attempts at exporting the SqlJs Module.

Author: Taytay

src/shell-post.js

@@ -7,9 +7,17 @@
   return initSqlJsPromise;
 } // The end of our initSqlJs function
 
-// This will allow the module to be used in ES6 or CommonJS
-initSqlJs.default = initSqlJs;
+// This bit below is copied almost exactly from what you get when you use the MODULARIZE=1 flag with emcc
+// However, we don't want to use the emcc modularization. See shell-pre.js
 if (typeof exports === 'object' && typeof module === 'object'){
     module.exports = initSqlJs;
+    // This will allow the module to be used in ES6 or CommonJS
+    module.exports.default = initSqlJs;
 }
-
+else if (typeof define === 'function' && define['amd']) {
+    define([], function() { return initSqlJs; });
+}
+else if (typeof exports === 'object'){
+    exports["Module"] = initSqlJs;
+}
+    

src/shell-pre.js

@@ -1,15 +1,16 @@
 
 // We are modularizing this manually because the current modularize setting in Emscripten has some issues:
 // https://github.com/kripken/emscripten/issues/5820
-// This module exports a promise that loads and resolves to the actual sql.js module.
+// In addition, When you use emcc's modularization, it still expects to export a global object called `Module`,
+// which is able to be used/called before the WASM is loaded.
+// The modularization below exports a promise that loads and resolves to the actual sql.js module.
 // That way, this module can't be used before the WASM is finished loading.
 
-
-// So the first thing that this module does is define a place for the loadedModule to reside
-
 // We are going to define a function that a user will call to start loading initializing our Sql.js library
-// However, that function might be called multiple times, and on subsequent calls, we want it to return the same module that it's already loaded once before.
+// However, that function might be called multiple times, and on subsequent calls, we don't actually want it to instantiate a new instance of the Module
+// Instead, we want to return the previously loaded module
 
+// TODO: Make this not declare a global if used in the browser
 var initSqlJsPromise = undefined;
 
 var initSqlJs = function (moduleConfig) {
@@ -18,7 +19,7 @@ var initSqlJs = function (moduleConfig) {
       return initSqlJsPromise;
     }
     // If we're here, we've never called this function before
-    initSqlJsPromise = new Promise((resolveModule) => {
+    initSqlJsPromise = new Promise((resolveModule, reject) => {
 
         // We are modularizing this manually because the current modularize setting in Emscripten has some issues:
         // https://github.com/kripken/emscripten/issues/5820
@@ -47,6 +48,24 @@ var initSqlJs = function (moduleConfig) {
             // When Emscripted calls postRun, this promise resolves with the built Module
             resolveModule(Module);
         });
+
+        // There is a section of code in the emcc-generated code below that looks like this:
+        // (Note that this is lowercase `module`)
+        // if (typeof module !== 'undefined') {
+        //     module['exports'] = Module;
+        // }
+        // When that runs, it's going to overwrite our own modularization export efforts in shell-post.js!
+        // The only way to tell emcc not to emit it is to pass the MODULARIZE=1 or MODULARIZE_INSTANCE=1 flags,
+        // but that carries with it additional unnecessary baggage/bugs we don't want either.
+        // So, we have three options:
+        // 1) We undefine `module`
+        // 2) We remember what `module['exports']` was at the beginning of this function and we restore it later
+        // 3) We write a script to remove those lines of code as part of the Make process.
+        //
+        // Since those are the only lines of code that care about module, we will undefine it. It's the most straightforward
+        // of the options, and has the side effect of reducing emcc's efforts to modify the module if its output were to change in the future.
+        // That's a nice side effect since we're handling the modularization efforts ourselves
+        module = undefined;
 
         // The emcc-generated code and shell-post.js code goes below,
         // meaning that all of it runs inside of this promise. If anything throws an exception, our promise will abort

test/load_sql_lib.js

@@ -1,5 +1,4 @@
 module.exports = function(sqlLibraryType){
-    var sqlLibraryType = process.argv[2];
     // Use sql-wasm.js by default
     var sqlJsLib = sqlLibraryType ? "../dist/sql-"+sqlLibraryType+".js" : "../dist/sql-wasm.js";
     begin = new Date();

test/test_modularization.js

@@ -0,0 +1,44 @@
+
+exports.test = function (SQL, assert, done, sqlLibFilename) {
+    if (!sqlLibFilename){
+        // Whew - this is ugly and fragile and makes way too many assumptions about how these tests are run from all.js
+        // However, this is the quickest way to make sure that we are testing the lib that is requested
+        const targetFile = process.argv[2];
+        sqlLibFilename = targetFile ? "../dist/sql-"+targetFile+".js" : "../dist/sql-wasm.js";
+    }
+
+    var initSqlJsLib1 = require(sqlLibFilename);
+    initSqlJsLib1().then((sqlModule1) => {
+        var initSqlJsLib2 = require(sqlLibFilename);
+        initSqlJsLib2().then((sqlModule2) => {
+            assert.equal(SQL, sqlModule1, "Initializing the module multiple times only creates it once");
+            assert.equal(sqlModule1, sqlModule2, "Initializing the module multiple times only creates it once");
+            var db1 = new sqlModule1.Database();
+            assert.equal(Object.getPrototypeOf(db1), SQL.Database.prototype, "sqlModule1 has a Database object that has the same prototype as the originally loaded SQL module");
+            assert.equal(Object.getPrototypeOf(db1), sqlModule2.Database.prototype, "sqlModule1 has a Database object that has the same prototype as the sqlModule2");
+            
+            
+            var db2 = new sqlModule2.Database();
+            assert.equal(Object.getPrototypeOf(db2), sqlModule1.Database.prototype, "sqlModule2 has a Database object that has the same prototype as the sqlModule1");
+
+            done();
+        });
+    });
+};
+
+if (module == require.main) {
+    const targetFile = process.argv[2];
+    const loadSqlLib = require('./load_sql_lib');
+    loadSqlLib(targetFile).then((sql) => {
+        require('test').run({
+            'test modularization': function (assert, done) {
+                // TODO: Dry this up so that this code isn't duped between here and load_sql_lib.js
+                var sqlJsLibFilename = targetFile ? "../dist/sql-"+targetFile+".js" : "../dist/sql-wasm.js";
+                exports.test(sql, assert, done, sqlJsLibFilename);
+            }
+        })
+    })
+    .catch((e) => {
+        console.error(e);
+    });
+}