prisma-laravel-migrate 0.2.2 → 0.2.3

package/dist/utils/config.js

@@ -1,13 +1,13 @@
 // loaders/config.ts
-import { pathToFileURL } from "url";
+import fs from "fs";
+import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import { extname, dirname, resolve } from "path";
-import fs from "fs";
-/** find nearest package.json and read its "type" (defaults to "commonjs") */
-function getNearestPkgType(fromPath) {
+import { pathToFileURL } from "url";
+function nearestPkgType(fromPath) {
     try {
         let dir = dirname(fromPath);
-        while (true) {
+        for (;;) {
             const pj = resolve(dir, "package.json");
             if (fs.existsSync(pj)) {
                 const type = JSON.parse(fs.readFileSync(pj, "utf8")).type;
@@ -22,48 +22,50 @@ function getNearestPkgType(fromPath) {
     catch { }
     return "commonjs";
 }
-// simple singleton cache to avoid double-loading the same file concurrently
-const configCache = new Map();
+const cache = new Map();
 async function loadConfigUniversal(absPath) {
-    const key = absPath;
-    if (configCache.has(key))
-        return configCache.get(key);
-    const promise = (async () => {
+    if (cache.has(absPath))
+        return cache.get(absPath);
+    const p = (async () => {
         const ext = extname(absPath).toLowerCase();
-        const projType = getNearestPkgType(absPath);
+        const projType = nearestPkgType(absPath);
         const asUrl = pathToFileURL(absPath).href;
         const req = createRequire(import.meta.url);
-        // Explicit extensions win:
-        if (ext === ".mjs") {
-            const mod = await import(asUrl);
-            return mod.default ?? mod;
-        }
+        // Explicit extensions
         if (ext === ".cjs") {
             const mod = req(absPath);
             return mod.default ?? mod;
         }
-        // .js is ambiguous: respect package.json "type"
-        if (projType === "module") {
-            // ESM project: load as ESM
+        if (ext === ".mjs") {
             const mod = await import(asUrl);
             return mod.default ?? mod;
         }
-        else {
-            // CJS project: load via require
+        // .js — ambiguous; read file to decide calmly
+        const code = await readFile(absPath, "utf8");
+        const looksCJS = /\bmodule\.exports\b|\bexports\s*=/.test(code);
+        if (projType === "commonjs" && looksCJS) {
+            // CJS project, CJS code → require
             const mod = req(absPath);
             return mod.default ?? mod;
         }
+        if (projType === "module" && looksCJS) {
+            // ESM project but CJS code → wrap on the fly via data URL
+            const wrapped = `const module = { exports: {} }; const exports = module.exports;\n` +
+                code +
+                `\nexport default module.exports;`;
+            const dataUrl = "data:text/javascript;base64," +
+                Buffer.from(wrapped, "utf8").toString("base64");
+            const mod = await import(dataUrl);
+            return mod.default ?? mod;
+        }
+        // Otherwise: treat as ESM
+        const mod = await import(asUrl);
+        return mod.default ?? mod;
     })();
-    configCache.set(key, promise);
-    try {
-        const cfg = await promise;
-        return cfg;
-    }
-    finally {
-        // keep it cached for this process; remove if you prefer one-shot
-    }
+    cache.set(absPath, p);
+    return p;
 }
 export async function loadConfig(configPath) {
-    return await loadConfigUniversal(configPath); // works for CJS or ESM
+    return await loadConfigUniversal(resolve(process.cwd(), configPath));
 }
 //# sourceMappingURL=config.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-laravel-migrate",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Generate laravel migrations and/or models using prisma files",
   "bin": {
     "prisma-laravel-migrations": "./dist/cli/migrator.index.js",