jaypie 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaypie",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "author": "Finlayson Studio",
   "type": "module",
   "main": "src/index.js",
@@ -17,7 +17,7 @@
     "test:spec:mongoose.package": "vitest run ./src/__tests__/mongoose.package.spec.js"
   },
   "dependencies": {
-    "@jaypie/core": "^0.4.0"
+    "@jaypie/core": "^0.4.1"
   },
   "devDependencies": {
     "@jaypie/testkit": "^1.0.0",
@@ -34,7 +34,7 @@
   },
   "peerDependencies": {
     "@jaypie/aws": "^0.1.1",
-    "@jaypie/lambda": "^0.1.1",
+    "@jaypie/lambda": "^0.1.3",
     "@jaypie/mongoose": "^0.1.1"
   },
   "peerDependenciesMeta": {

package/src/__tests__/dynamicExport.function.spec.js

@@ -73,13 +73,24 @@ describe("Dynamic Export Function", () => {
     it("Returns an object", () => {
       expect(dynamicExport({ moduleImport: MOCK.MODULE })).toBeObject();
     });
-    it("Scalars are undefined when module is not found", async () => {
+    it("If module is not found and you try to get a scalar it will throw", async () => {
       const vars = ["scalar"];
       const result = await dynamicExport({
         vars,
         moduleImport: MOCK.MODULE,
       });
-      expect(result.scalar).toBeUndefined();
+      await expect(() => {
+        console.log("result.scalar :>> ", result.scalar);
+        try {
+          console.log("result.scalar.taco :>> ", result.scalar.taco);
+        } catch (error) {
+          console.log("error :>> ", error);
+        }
+        if (result.scalar) {
+          return true;
+        }
+        return false;
+      }).toThrow();
     });
     it("Exported functions throw if the real module is not installed", async () => {
       const functions = ["default"];
@@ -87,7 +98,17 @@ describe("Dynamic Export Function", () => {
         functions,
         moduleImport: MOCK.MODULE,
       });
-      await expect(result.default()).rejects.toThrow();
+      await expect(() => {
+        result.default();
+      }).toThrow();
+    });
+    it("Scalars that never existed are undefined", async () => {
+      const vars = ["scalar"];
+      const result = await dynamicExport({
+        vars,
+        moduleImport: MOCK.MODULE,
+      });
+      expect(result.bogus).toBeUndefined();
     });
   });
   describe("Features", () => {

package/src/__tests__/mongoose.package.spec.js

@@ -9,7 +9,7 @@ import {
 } from "vitest";
 
 // Subject
-import { connectFromSecretEnv, disconnect } from "../mongoose.package.js";
+// * Subject is imported dynamically to allow `vi.resetModules()` to apply different mocks
 
 //
 //
@@ -41,6 +41,16 @@ afterEach(() => {
 //
 
 describe("Mongoose Package", () => {
+  let connectFromSecretEnv;
+  let disconnect;
+  beforeAll(async () => {
+    const {
+      connectFromSecretEnv: _connectFromSecretEnv,
+      disconnect: _disconnect,
+    } = await import("../mongoose.package.js");
+    connectFromSecretEnv = _connectFromSecretEnv;
+    disconnect = _disconnect;
+  });
   it("Works", () => {
     expect(connectFromSecretEnv).toBeFunction();
     expect(disconnect).toBeFunction();
@@ -58,7 +68,8 @@ describe("Mongoose Package", () => {
   describe("Features", () => {
     const mockConnectFromSecretEnv = vi.fn();
     const mockDisconnect = vi.fn();
-    beforeAll(() => {
+    beforeAll(async () => {
+      // Setup mock of mongoose
       vi.doMock("@jaypie/mongoose", () => {
         return {
           connectFromSecretEnv: mockConnectFromSecretEnv,
@@ -68,6 +79,15 @@ describe("Mongoose Package", () => {
           },
         };
       });
+      // Preprocess
+      vi.resetModules();
+      const {
+        connectFromSecretEnv: _connectFromSecretEnv,
+        disconnect: _disconnect,
+      } = await import("../mongoose.package.js");
+      // Return
+      connectFromSecretEnv = _connectFromSecretEnv;
+      disconnect = _disconnect;
     });
     it("Calls @jaypie/mongoose for connectFromSecretEnv", async () => {
       await connectFromSecretEnv();

package/src/dynamicExport.function.js

@@ -56,26 +56,28 @@ export default async ({
       "Either `functions` or `vars` must be provided",
     );
   }
-  // Setup
-  const returning = {};
   // Process
-  for (const key of functions) {
-    returning[key] = async () => {
-      const imported = await dynamicImport(moduleImport);
-      return await imported[key]();
-    };
-  }
-  let imported = {};
   try {
-    imported = await dynamicImport(moduleImport);
+    // Attempt to import the module
+    return await dynamicImport(moduleImport);
   } catch (error) {
     moduleLogger.trace(
       `[jaypie] ${moduleImport} could not be imported; continuing`,
     );
   }
-  for (const key of vars) {
-    returning[key] = imported[key];
-  }
   // Return
-  return returning;
+  // * Returns a proxy that throws if you call a functions or get a vars
+  return new Proxy(
+    {},
+    {
+      get: (target, prop) => {
+        if (functions.includes(prop) || vars.includes(prop)) {
+          throw new ConfigurationError(
+            `Attempted to access ${prop} from ${moduleImport}, but it is not installed`,
+          );
+        }
+        return undefined;
+      },
+    },
+  );
 };