From 6197a4cb8811a1d3c1775571ac188d7cba6e2e27 Mon Sep 17 00:00:00 2001
From: Izel Nakri <contact@izelnakri.com>
Date: Sun, 2 Feb 2020 21:45:47 +0100
Subject: [PATCH] Some smart wiring to expose models to window.$Model if needed

---
 package.json  |  2 +-
 src/index.ts  | 31 ++-----------------------------
 src/model.ts  |  2 ++
 src/server.ts | 24 ++++++++++++++++++------
 4 files changed, 23 insertions(+), 36 deletions(-)

diff --git a/package.json b/package.json
index 341e589..72052dd 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,7 @@
   },
   "funding": {
     "type": "opencollective",
-    "url": "https://opencollective.com/sinon"
+    "url": "https://opencollective.com/memserver"
   },
   "license": "MIT",
   "bin": {
diff --git a/src/index.ts b/src/index.ts
index 018bff4..917dfe4 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -41,46 +41,19 @@ const CWD = process.cwd();
   await setupDom();
 
   const modelFileNames = await fs.readdir(`${CWD}/memserver/models`);
-  const modelRegistry = await Promise.all(
-    modelFileNames.map(async (fileName) => {
-      const modelName = fileName.slice(0, -3);
-      const fixturePath = `${CWD}/memserver/fixtures/${dasherize(pluralize(modelName))}`;
-      const fixtureExists = await fs.pathExists(`${fixturePath}.ts`);
-
-      const [model, fixtures] = await Promise.all([
-        import(`${CWD}/memserver/models/${fileName}`),
-        fixtureExists ? import(fixturePath) : { default: [] }
-      ]);
-
-      return {
-        [classify(modelName)]: {
-          model: model.default,
-          fixtures: fixtures.default
-        }
-      };
-    }, [])
-  );
 
   window.Memserver = (await import("./server")).default;
+
   const [initializerModule, routesModule] = await Promise.all([
     import(`${CWD}/memserver/initializer`),
     import(`${CWD}/memserver/routes`)
   ]);
 
   window.MemServer = new window.Memserver({
+    globalizeModels: true,
     initializer: initializerModule.default,
     routes: routesModule.default
   });
-  window.modelRegistry = modelRegistry;
-
-  modelRegistry.forEach((modelRegister) => {
-    const modelName = Object.keys(modelRegister)[0];
-
-    window[modelName] = modelRegister[modelName].model;
-    window[modelName].resetDatabase(modelRegister[modelName].fixtures);
-  });
 
   return window.MemServer;
 })();
-
-// import('./dist').then((memserver) => global.MemServer = memserver)
diff --git a/src/model.ts b/src/model.ts
index d162803..d3d9cdb 100644
--- a/src/model.ts
+++ b/src/model.ts
@@ -21,6 +21,7 @@ export type InternalModel = RequireOnlyOne<InternalModelShape, "id" | "uuid">;
 
 export default abstract class MemServerModel {
   static _DB = {};
+  static _modelDefinitions = [];
   static _attributes = {};
   static _defaultAttributes = {}; // NOTE: probably a decorator here in future
   static _embedReferences = {}; // NOTE: serializer concern
@@ -39,6 +40,7 @@ export default abstract class MemServerModel {
   static get attributes(): Array<string> {
     if (!this._attributes[this.name]) {
       this._attributes[this.name] = [];
+      this._modelDefinitions.push(this);
 
       return this._attributes[this.name];
     }
diff --git a/src/server.ts b/src/server.ts
index ae327f5..37c3d2b 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -27,15 +27,27 @@ interface MemserverOptions {
 }
 
 export default class Memserver {
-  models: void | Array<Model> = null;
-  globalizeModels: boolean = false;
-
   constructor(options: MemserverOptions = { logging: true }) {
-    const initializer = options.initializer || function() {};
+    const initializer = options.initializer || async function() {};
     const routes = options.routes || function() {};
     const logging = options.hasOwnProperty("logging") ? options.logging : true;
-
-    initializer();
+    const initializerReturn = initializer();
+
+    if (initializerReturn instanceof Promise) {
+      initializerReturn.then(() => {
+        if (options.globalizeModels) {
+          Model._modelDefinitions.forEach((model) => {
+            window[model.name] = model;
+          });
+        }
+      });
+    } else {
+      if (options.globalizeModels) {
+        Model._modelDefinitions.forEach((model) => {
+          window[model.name] = model;
+        });
+      }
+    }
 
     return startPretender(routes, Object.assign(options, { logging }));
   }