@mastra/deployer 0.0.0-commonjs-20250227130920

package/dist/build/bundler.cjs

@@ -0,0 +1,353 @@
+'use strict';
+
+var alias = require('@rollup/plugin-alias');
+var commonjs = require('@rollup/plugin-commonjs');
+var json = require('@rollup/plugin-json');
+var nodeResolve = require('@rollup/plugin-node-resolve');
+var url = require('url');
+var rollup = require('rollup');
+var esbuild = require('rollup-plugin-esbuild');
+var babel = require('@babel/core');
+var load = require('@neon-rs/load');
+var detectLibc = require('detect-libc');
+var path = require('path');
+var fsExtra = require('fs-extra/esm');
+var helperModuleImports = require('@babel/helper-module-imports');
+var process$1 = require('process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var alias__default = /*#__PURE__*/_interopDefault(alias);
+var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
+var json__default = /*#__PURE__*/_interopDefault(json);
+var nodeResolve__default = /*#__PURE__*/_interopDefault(nodeResolve);
+var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
+var babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+var fsExtra__default = /*#__PURE__*/_interopDefault(fsExtra);
+
+// src/build/bundler.ts
+function rewriteLibsqlImport() {
+  const t = babel__namespace.default.types;
+  let hasReplaced = false;
+  return {
+    name: "rewrite-libsql-import",
+    visitor: {
+      FunctionDeclaration(path) {
+        if (path.node.id?.name === "requireNative" && !hasReplaced) {
+          hasReplaced = true;
+          const createRequire = helperModuleImports.addNamed(path, "createRequire", "module");
+          const requireIdentifier = t.identifier("require");
+          path.replaceWith(
+            t.functionDeclaration(
+              t.identifier("requireNative"),
+              [],
+              t.blockStatement([
+                t.variableDeclaration("const", [
+                  t.variableDeclarator(
+                    requireIdentifier,
+                    t.callExpression(createRequire, [
+                      t.memberExpression(
+                        t.metaProperty(t.identifier("import"), t.identifier("meta")),
+                        t.identifier("url")
+                      )
+                    ])
+                  )
+                ]),
+                t.returnStatement(t.callExpression(requireIdentifier, [t.stringLiteral("./libsql.node")]))
+              ])
+            )
+          );
+        }
+      }
+    }
+  };
+}
+
+// src/build/plugins/fix-libsql.ts
+function libSqlFix() {
+  return {
+    name: "libSqlFix",
+    transform(code, id) {
+      if (!id.includes("\\libsql\\index.js") && !id.includes("/libsql/index.js")) {
+        return null;
+      }
+      return new Promise((resolve2, reject) => {
+        babel__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [rewriteLibsqlImport]
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve2({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
+    },
+    async generateBundle({ file, dir }) {
+      if (!file && !dir) {
+        throw new Error("No output options were given.");
+      }
+      const outputDirectory = dir || path.dirname(file);
+      let target = load.currentTarget();
+      if (detectLibc.familySync() == detectLibc.GLIBC) {
+        switch (target) {
+          case "linux-x64-musl":
+            target = "linux-x64-gnu";
+            break;
+          case "linux-arm64-musl":
+            target = "linux-arm64-gnu";
+            break;
+        }
+      }
+      const fileToCopy = await this.resolve(`@libsql/${target}/index.node`);
+      if (fileToCopy) {
+        await fsExtra__default.default.copy(fileToCopy.id, path.join(outputDirectory, "libsql.node"));
+      }
+    }
+  };
+}
+function removeDeployer() {
+  const t = babel__namespace.default.types;
+  let mastraClass = null;
+  return {
+    name: "remove-deployer",
+    visitor: {
+      ImportDeclaration(path) {
+        if ((path.node.source.value === "@mastra/core" || path.node.source.value === "@mastra/core/mastra") && path.node.specifiers) {
+          const mastraObj = path.node.specifiers.find(
+            (p) => t.isImportSpecifier(p) && t.isIdentifier(p.imported) && p.imported.name === "Mastra"
+          );
+          if (mastraObj?.local?.name) {
+            mastraClass = mastraObj.local.name;
+          }
+        }
+      },
+      NewExpression(path, state) {
+        if (mastraClass && t.isIdentifier(path.node.callee) && path.node.callee.name === mastraClass && !state.hasReplaced) {
+          state.hasReplaced = true;
+          const newMastraObj = t.cloneNode(path.node);
+          if (t.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.[0]) {
+            newMastraObj.arguments[0].properties = newMastraObj.arguments[0].properties.filter(
+              (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name !== "deployer"
+            );
+            path.replaceWith(newMastraObj);
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/build/plugins/remove-deployer.ts
+function removeDeployer2(mastraEntry) {
+  return {
+    name: "remove-deployer",
+    transform(code, id) {
+      if (id !== mastraEntry) {
+        return;
+      }
+      return new Promise((resolve2, reject) => {
+        babel__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeDeployer]
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve2({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
+    }
+  };
+}
+function getTelemetryMachineFile() {
+  switch (process$1.platform) {
+    case "darwin":
+      return "getMachineId-darwin";
+    case "linux":
+      return "getMachineId-linux";
+    case "freebsd":
+      return "getMachineId-bsd";
+    case "win32":
+      return "getMachineId-win";
+    default:
+      return "getMachineId-unsupported";
+  }
+}
+function telemetryFix() {
+  return {
+    name: "telemetry-fix",
+    transform(code, id) {
+      if (id.includes("require-in-the-middle")) {
+        return code.replace(
+          `const path = require('path')`,
+          `const path = require('path');
+      const { createRequire } = require('module');
+      const realRequire = createRequire(import.meta.url)`
+        ).replaceAll(`require.resolve`, `realRequire.resolve`);
+      }
+    },
+    resolveId(id, importer) {
+      if (id === "./machine-id/getMachineId" && importer) {
+        return { id: path.resolve(path.dirname(importer), `./machine-id/${getTelemetryMachineFile()}.js`) };
+      }
+      if (id === "formdata-node") {
+        return { id: "formdata-node", external: false };
+      }
+    },
+    load(id) {
+      if (id.startsWith("formdata-node")) {
+        return "export default {};";
+      }
+      return null;
+    }
+  };
+}
+
+// src/build/bundler.ts
+async function getInputOptions(entryFile, analyzedBundleInfo, platform2) {
+  let nodeResolvePlugin = platform2 === "node" ? nodeResolve__default.default({
+    preferBuiltins: true,
+    exportConditions: ["node", "import", "require"],
+    mainFields: ["module", "main"]
+  }) : nodeResolve__default.default({
+    preferBuiltins: false,
+    exportConditions: ["browser", "import", "require"],
+    mainFields: ["module", "main"],
+    browser: true
+  });
+  const externals = Array.from(analyzedBundleInfo.externalDependencies).concat(["@mastra/core/hooks"]);
+  return {
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    treeshake: true,
+    preserveSymlinks: true,
+    external: externals,
+    plugins: [
+      telemetryFix(),
+      libSqlFix(),
+      {
+        name: "alias-optimized-deps",
+        // @ts-ignore
+        resolveId(id) {
+          if (!analyzedBundleInfo.dependencies.has(id)) {
+            return null;
+          }
+          const isInvalidChunk = analyzedBundleInfo.invalidChunks.has(analyzedBundleInfo.dependencies.get(id));
+          if (isInvalidChunk) {
+            return {
+              id,
+              external: true
+            };
+          }
+          return {
+            id: ".mastra/.build/" + analyzedBundleInfo.dependencies.get(id),
+            external: false
+          };
+        }
+      },
+      alias__default.default({
+        entries: [
+          {
+            find: /^\#server$/,
+            replacement: url.fileURLToPath(undefined("@mastra/deployer/server")).replaceAll("\\", "/")
+          },
+          { find: /^\#mastra$/, replacement: entryFile.replaceAll("\\", "/") }
+        ]
+      }),
+      esbuild__default.default({
+        target: "node20",
+        platform: platform2,
+        minify: false,
+        define: {
+          "process.env.NODE_ENV": JSON.stringify("production")
+        }
+      }),
+      commonjs__default.default({
+        extensions: [".js", ".ts"],
+        transformMixedEsModules: true,
+        esmExternals(id) {
+          return externals.includes(id);
+        }
+      }),
+      nodeResolvePlugin,
+      // for debugging
+      // {
+      //   name: 'logger',
+      //   //@ts-ignore
+      //   resolveId(id, ...args) {
+      //     console.log({ id, args });
+      //   },
+      //   // @ts-ignore
+      // transform(code, id) {
+      //   if (code.includes('class Duplexify ')) {
+      //     console.log({ duplex: id });
+      //   }
+      // },
+      // },
+      json__default.default(),
+      removeDeployer2(entryFile),
+      // treeshake unused imports
+      esbuild__default.default({
+        include: entryFile,
+        target: "node20",
+        platform: platform2,
+        minify: false
+      })
+    ].filter(Boolean)
+  };
+}
+async function createBundler(inputOptions, outputOptions) {
+  const bundler = await rollup.rollup(inputOptions);
+  return {
+    write: () => {
+      return bundler.write({
+        ...outputOptions,
+        format: "esm",
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "[name].mjs"
+      });
+    },
+    close: () => {
+      return bundler.close();
+    }
+  };
+}
+
+exports.createBundler = createBundler;
+exports.getInputOptions = getInputOptions;

package/dist/build/bundler.d.cts

@@ -0,0 +1,2 @@
+export { getInputOptions } from '../_tsup-dts-rollup.cjs';
+export { createBundler } from '../_tsup-dts-rollup.cjs';

package/dist/build/bundler.d.ts

@@ -0,0 +1,2 @@
+export { getInputOptions } from '../_tsup-dts-rollup.js';
+export { createBundler } from '../_tsup-dts-rollup.js';

package/dist/build/bundler.js

@@ -0,0 +1,2 @@
+export { createBundler, getInputOptions } from '../chunk-DTSFVNIF.js';
+import '../chunk-YNXJO2XU.js';