jaypie 0.1.2 → 0.1.4

package/.vscode/settings.json

@@ -14,6 +14,7 @@
     "oidc",
     "pinia",
     "roboto",
+    "testkit",
     "unplugin",
     "vendia",
     "vuekit",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaypie",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "author": "Finlayson Studio",
   "type": "module",
   "main": "src/index.js",
@@ -20,6 +20,7 @@
     "@jaypie/core": "^0.4.0"
   },
   "devDependencies": {
+    "@jaypie/testkit": "^1.0.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",

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

@@ -44,67 +44,109 @@ describe("Dynamic Export Function", () => {
     expect(dynamicExport).toBeFunction();
   });
   describe("Error Handling", () => {
-    it("Throws if exports is not an array", () => {
-      expect(() => dynamicExport({ exports: "string" })).toThrow();
+    it("Throws if functions is not an array", async () => {
+      try {
+        await dynamicExport({ functions: "default" });
+      } catch (error) {
+        expect(error).toBeJaypieError();
+      }
+      expect.assertions(1);
     });
-    it("Throws if exports is an empty array", () => {
-      expect(() => dynamicExport({ exports: [] })).toThrow();
+    it("Throws if functions is an empty array", async () => {
+      try {
+        await dynamicExport({ functions: [] });
+      } catch (error) {
+        expect(error).toBeJaypieError();
+      }
+      expect.assertions(1);
     });
-    it("Throws if moduleImport is not a string", () => {
-      expect(() => dynamicExport({ moduleImport: 123 })).toThrow();
+    it("Throws if moduleImport is not a string", async () => {
+      try {
+        await dynamicExport({ moduleImport: 12 });
+      } catch (error) {
+        expect(error).toBeJaypieError();
+      }
+      expect.assertions(1);
     });
   });
   describe("Happy Path", () => {
     it("Returns an object", () => {
       expect(dynamicExport({ moduleImport: MOCK.MODULE })).toBeObject();
     });
-    it("Returns an object with the exports", () => {
-      const exports = ["default", "named"];
-      const result = dynamicExport({ exports, moduleImport: MOCK.MODULE });
-      expect(result).toContainKeys(exports);
-    });
-    it("Returns an object with the exports as functions", () => {
-      const exports = ["default", "named"];
-      const result = dynamicExport({ exports, moduleImport: MOCK.MODULE });
-      expect(result.default).toBeFunction();
-      expect(result.named).toBeFunction();
+    it("Scalars are undefined when module is not found", async () => {
+      const vars = ["scalar"];
+      const result = await dynamicExport({
+        vars,
+        moduleImport: MOCK.MODULE,
+      });
+      expect(result.scalar).toBeUndefined();
     });
     it("Exported functions throw if the real module is not installed", async () => {
-      const exports = ["default"];
-      const result = dynamicExport({ exports, moduleImport: MOCK.MODULE });
-      await expect(result.default()).rejects.toThrow();
+      const functions = ["default"];
+      const result = await dynamicExport({
+        functions,
+        moduleImport: MOCK.MODULE,
+      });
+      await expect(result.default).toThrow();
     });
   });
   describe("Features", () => {
     const mockDefaultFunction = vi.fn();
     const mockNamedFunction = vi.fn();
-    const mockScalar = "scalar";
+    const mockVarName = "scalar";
+    const mockVarValue = "value";
     beforeAll(() => {
       vi.doMock(MOCK.MODULE, () => {
         return {
           default: mockDefaultFunction,
           named: mockNamedFunction,
-          scalar: mockScalar,
+          [mockVarName]: mockVarValue,
         };
       });
     });
     it("Calls the default function", async () => {
-      const exports = ["default", "named"];
-      const result = dynamicExport({ exports, moduleImport: MOCK.MODULE });
+      const functions = ["default", "named"];
+      const result = await dynamicExport({
+        functions,
+        moduleImport: MOCK.MODULE,
+      });
       await result.default();
       expect(mockDefaultFunction).toHaveBeenCalled();
     });
     it("Calls the named function", async () => {
-      const exports = ["default", "named"];
-      const result = dynamicExport({ exports, moduleImport: MOCK.MODULE });
+      const functions = ["default", "named"];
+      const result = await dynamicExport({
+        functions,
+        moduleImport: MOCK.MODULE,
+      });
       await result.named();
       expect(mockNamedFunction).toHaveBeenCalled();
     });
-    it.todo("Returns the scalar", async () => {
-      const exports = ["scalar"];
-      const result = dynamicExport({ exports, moduleImport: MOCK.MODULE });
-      expect(result.scalar).not.toBeFunction();
-      expect(result.scalar).toBe(mockScalar);
+    it("Returns the scalar", async () => {
+      const vars = [mockVarName];
+      const result = await dynamicExport({
+        vars,
+        moduleImport: MOCK.MODULE,
+      });
+      expect(result[mockVarName]).not.toBeFunction();
+      expect(result[mockVarName]).toBe(mockVarValue);
+    });
+    it("Returns an object with the functions", async () => {
+      const functions = ["default", "named"];
+      const result = await dynamicExport({
+        functions,
+        moduleImport: MOCK.MODULE,
+      });
+      expect(result).toContainKeys(functions);
+    });
+    it("Returns an object with the functions as functions", async () => {
+      const functions = ["default", "named"];
+      const result = await dynamicExport({
+        functions,
+        moduleImport: MOCK.MODULE,
+      });
+      expect(result.default).toBeFunction();
+      expect(result.named).toBeFunction();
     });
   });
 });

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/aws.package.js

@@ -6,7 +6,7 @@ import dynamicExport from "./dynamicExport.function.js";
 // Export
 //
 
-export const { getSecret } = dynamicExport({
-  exports: ["getSecret"],
+export const { getSecret } = await dynamicExport({
+  functions: ["getSecret"],
   moduleImport: JAYPIE.LIB.AWS,
 });

package/src/dynamicExport.function.js

@@ -36,20 +36,57 @@ async function dynamicImport(module) {
 // Main
 //
 
-export default ({ exports = ["default"], moduleImport } = {}) => {
+export default async ({
+  functions = ["default"],
+  moduleImport,
+  vars = [],
+} = {}) => {
   // Validate
-  if (Array.isArray(exports) && !exports.length) {
-    throw new ConfigurationError();
-  }
   if (!moduleImport || typeof moduleImport !== "string") {
-    throw new ConfigurationError();
+    throw new ConfigurationError("`moduleImport` must be a string");
+  }
+  if (!Array.isArray(functions)) {
+    throw new ConfigurationError("`functions` must be an array");
+  }
+  if (!Array.isArray(vars)) {
+    throw new ConfigurationError("`vars` must be an array");
+  }
+  if (!functions.length && !vars.length) {
+    throw new ConfigurationError(
+      "Either `functions` or `vars` must be provided",
+    );
   }
   // Setup
-  return exports.reduce((acc, key) => {
-    acc[key] = async () => {
-      const imported = await dynamicImport(moduleImport);
-      return await imported[key]();
-    };
-    return acc;
-  }, {});
+  let imported;
+  const returning = {};
+  // Preprocess
+  try {
+    imported = await dynamicImport(moduleImport);
+  } catch (error) {
+    moduleLogger.trace(
+      `[jaypie] ${moduleImport} could not be imported; continuing`,
+    );
+  }
+  // Process
+  for (const key of functions) {
+    if (imported) {
+      returning[key] = imported[key];
+    } else {
+      returning[key] = () => {
+        throw new ConfigurationError(
+          `Function ${key} cannot be called because ${moduleImport} is not installed`,
+        );
+      };
+    }
+  }
+  for (const key of vars) {
+    if (imported) {
+      returning[key] = imported[key];
+    } else {
+      // TODO: make the not found vars throw only _when accessed_
+      returning[key] = undefined;
+    }
+  }
+  // Return
+  return returning;
 };

package/src/index.js

@@ -3,8 +3,10 @@
 // Export
 //
 
+// Required dependencies
 export * from "@jaypie/core";
 
+// Optional dependencies are wrapped in a dynamic import
 export * from "./aws.package.js";
 export * from "./lambda.package.js";
 export * from "./mongoose.package.js";

package/src/lambda.package.js

@@ -6,7 +6,7 @@ import dynamicExport from "./dynamicExport.function.js";
 // Export
 //
 
-export const { lambdaHandler } = dynamicExport({
-  exports: ["lambdaHandler"],
+export const { lambdaHandler } = await dynamicExport({
+  functions: ["lambdaHandler"],
   moduleImport: JAYPIE.LIB.LAMBDA,
 });

package/src/mongoose.package.js

@@ -6,7 +6,7 @@ import dynamicExport from "./dynamicExport.function.js";
 // Export
 //
 
-export const { connectFromSecretEnv, disconnect } = dynamicExport({
-  exports: ["connectFromSecretEnv", "disconnect"],
+export const { connectFromSecretEnv, disconnect } = await dynamicExport({
+  functions: ["connectFromSecretEnv", "disconnect"],
   moduleImport: JAYPIE.LIB.MONGOOSE,
 });

package/testSetup.js

@@ -1,3 +1,6 @@
+import { matchers as jaypieMatchers } from "@jaypie/testkit";
+import * as extendedMatchers from "jest-extended";
 import { expect } from "vitest";
-import * as matchers from "jest-extended";
-expect.extend(matchers);
+
+expect.extend(extendedMatchers);
+expect.extend(jaypieMatchers);