@mastra/deployer 0.0.0-commonjs-20250227130920

package/dist/chunk-JMH7HCD6.js

@@ -0,0 +1,274 @@
+import { removeDeployer } from './chunk-YNXJO2XU.js';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import virtual from '@rollup/plugin-virtual';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { rollup } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+import { builtinModules } from 'node:module';
+
+function isNodeBuiltin(dep) {
+  const [pkg] = dep.split("/");
+  return dep.startsWith("node:") || builtinModules.includes(dep) || builtinModules.includes(pkg);
+}
+function aliasHono() {
+  return {
+    name: "hono-alias",
+    resolveId(id) {
+      if (!id.startsWith("@hono/") && !id.startsWith("hono/") && id !== "hono" && id !== "hono-openapi") {
+        return;
+      }
+      const path = import.meta.resolve(id);
+      return fileURLToPath(path);
+    }
+  };
+}
+
+// src/build/plugins/pino.ts
+function pino() {
+  const workerFiles = [
+    {
+      id: "thread-stream-worker",
+      file: "pino-thread-stream-worker"
+    },
+    {
+      id: "pino-worker",
+      file: "pino-worker"
+    },
+    {
+      id: "pino/file",
+      file: "pino-file"
+    },
+    {
+      id: "pino-pretty",
+      file: "pino-pretty"
+    }
+  ];
+  const fileReferences = /* @__PURE__ */ new Map();
+  return {
+    name: "rollup-plugin-pino",
+    async resolveId(id, importee) {
+      if (id === "pino") {
+        const resolvedPino = await this.resolve(id, importee);
+        if (resolvedPino) {
+          await Promise.all(
+            workerFiles.map(async (file) => {
+              const resolvedEntry = await this.resolve(file.id, resolvedPino.id);
+              if (!resolvedEntry) {
+                return null;
+              }
+              const reference = this.emitFile({
+                type: "chunk",
+                id: resolvedEntry.id,
+                name: `${file.file}`
+              });
+              fileReferences.set(file.id, reference);
+            })
+          );
+        }
+      }
+    },
+    renderChunk(code, chunk) {
+      if (chunk.type === "chunk" && chunk.isEntry && fileReferences.size && chunk.name === "index") {
+        const importRegex = /^(?:import(?:["'\s]*[\w*${}\n\r\t, ]+from\s*)?["'\s].+[;"'\s]*)$/gm;
+        const codeToInject = `globalThis.__bundlerPathsOverrides = {
+            ${Array.from(fileReferences.entries()).map(([key, file]) => {
+          return '"' + key + '": import.meta.ROLLUP_FILE_URL_' + file;
+        }).join(",\n")}
+            };`;
+        const matches = Array.from(code.matchAll(importRegex));
+        if (matches.length > 0) {
+          const lastImport = matches[matches.length - 1];
+          const lastImportEnd = lastImport.index + lastImport[0].length;
+          const newCode = code.slice(0, lastImportEnd) + "\n\n" + codeToInject + "\n\n" + code.slice(lastImportEnd);
+          return {
+            code: newCode,
+            map: null
+          };
+        }
+        return {
+          code: `${codeToInject}
+
+${code}`,
+          map: null
+        };
+      }
+    }
+  };
+}
+
+// src/build/analyze.ts
+async function analyze(entry, mastraEntry, isVirtualFile, platform, logger) {
+  logger.info("Analyzing dependencies...");
+  let virtualPlugin = null;
+  if (isVirtualFile) {
+    virtualPlugin = virtual({
+      "#entry": entry
+    });
+    entry = "#entry";
+  }
+  const optimizerBundler = await rollup({
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    input: isVirtualFile ? "#entry" : entry,
+    treeshake: true,
+    preserveSymlinks: true,
+    plugins: [
+      virtualPlugin,
+      {
+        name: "custom-alias-resolver",
+        resolveId(id) {
+          if (id === "#server") {
+            return fileURLToPath(import.meta.resolve("@mastra/deployer/server")).replaceAll("\\", "/");
+          }
+          if (id === "#mastra") {
+            return mastraEntry.replaceAll("\\", "/");
+          }
+        }
+      },
+      json(),
+      commonjs({
+        strictRequires: "debug",
+        ignoreTryCatch: false,
+        transformMixedEsModules: true,
+        extensions: [".js", ".ts"]
+      }),
+      esbuild({
+        target: "node20",
+        platform,
+        minify: false
+      }),
+      removeDeployer(mastraEntry),
+      esbuild({
+        target: "node20",
+        platform,
+        minify: false
+      })
+    ].filter(Boolean)
+  });
+  const { output } = await optimizerBundler.generate({
+    format: "esm",
+    inlineDynamicImports: true
+  });
+  await optimizerBundler.close();
+  const depsToOptimize = new Map(Object.entries(output[0].importedBindings));
+  for (const dep of depsToOptimize.keys()) {
+    if (isNodeBuiltin(dep)) {
+      depsToOptimize.delete(dep);
+    }
+  }
+  return depsToOptimize;
+}
+async function bundleExternals(depsToOptimize, outputDir, logger) {
+  logger.info("Optimizing dependencies...");
+  logger.debug(
+    `${Array.from(depsToOptimize.keys()).map((key) => `- ${key}`).join("\n")}`
+  );
+  const reverseVirtualReferenceMap = /* @__PURE__ */ new Map();
+  const virtualDependencies = /* @__PURE__ */ new Map();
+  for (const [dep, exports] of depsToOptimize.entries()) {
+    const name = dep.replaceAll("/", "-");
+    reverseVirtualReferenceMap.set(name, dep);
+    const virtualFile = [];
+    let exportStringBuilder = [];
+    for (const local of exports) {
+      if (local === "*") {
+        virtualFile.push(`export * from '${dep}';`);
+      } else if (local === "default") {
+        virtualFile.push(`export * from '${dep}';`);
+      } else {
+        exportStringBuilder.push(local);
+      }
+    }
+    if (exportStringBuilder.length > 0) {
+      virtualFile.push(`export { ${exportStringBuilder.join(", ")} } from '${dep}';`);
+    }
+    virtualDependencies.set(dep, {
+      name,
+      virtual: virtualFile.join("\n")
+    });
+  }
+  const bundler = await rollup({
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    input: Array.from(virtualDependencies.entries()).reduce(
+      (acc, [dep, virtualDep]) => {
+        acc[virtualDep.name] = `#virtual-${dep}`;
+        return acc;
+      },
+      {}
+    ),
+    // this dependency breaks the build, so we need to exclude it
+    // TODO actually fix this so we don't need to exclude it
+    external: ["jsdom"],
+    treeshake: "smallest",
+    preserveSymlinks: true,
+    plugins: [
+      virtual(
+        Array.from(virtualDependencies.entries()).reduce(
+          (acc, [dep, virtualDep]) => {
+            acc[`#virtual-${dep}`] = virtualDep.virtual;
+            return acc;
+          },
+          {}
+        )
+      ),
+      pino(),
+      commonjs({
+        strictRequires: "strict",
+        transformMixedEsModules: true,
+        ignoreTryCatch: false
+      }),
+      nodeResolve({
+        preferBuiltins: true,
+        exportConditions: ["node", "import", "require"],
+        mainFields: ["module", "main"]
+      }),
+      // hono is imported from deployer, so we need to resolve from here instead of the project root
+      aliasHono(),
+      json()
+    ].filter(Boolean)
+  });
+  const { output } = await bundler.write({
+    format: "esm",
+    dir: outputDir,
+    entryFileNames: "[name].mjs",
+    chunkFileNames: "[name].mjs"
+  });
+  await bundler.close();
+  return { output, reverseVirtualReferenceMap };
+}
+async function validateOutput(output, reverseVirtualReferenceMap, outputDir, logger) {
+  const result = {
+    invalidChunks: /* @__PURE__ */ new Set(),
+    dependencies: /* @__PURE__ */ new Map(),
+    externalDependencies: /* @__PURE__ */ new Set()
+  };
+  for (const file of output) {
+    if (file.type === "asset") {
+      continue;
+    }
+    try {
+      logger.debug(`Validating if ${file.fileName} is a valid module.`);
+      if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) {
+        result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
+      }
+      await import(`file:${outputDir}/${file.fileName}`);
+    } catch (err) {
+      result.invalidChunks.add(file.fileName);
+      if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) {
+        result.externalDependencies.add(reverseVirtualReferenceMap.get(file.name));
+      }
+    }
+  }
+  return result;
+}
+async function analyzeBundle(entry, mastraEntry, outputDir, platform, logger) {
+  const isVirtualFile = entry.includes("\n") || !existsSync(entry);
+  const depsToOptimize = await analyze(entry, mastraEntry, isVirtualFile, platform, logger);
+  const { output, reverseVirtualReferenceMap } = await bundleExternals(depsToOptimize, outputDir, logger);
+  const result = await validateOutput(output, reverseVirtualReferenceMap, outputDir, logger);
+  return result;
+}
+
+export { aliasHono, analyzeBundle };

package/dist/chunk-SGK37ZWD.js

@@ -0,0 +1,254 @@
+import { aliasHono } from './chunk-JMH7HCD6.js';
+import { getInputOptions, telemetryFix, libSqlFix } from './chunk-DTSFVNIF.js';
+import { removeDeployer } from './chunk-YNXJO2XU.js';
+import alias from '@rollup/plugin-alias';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import { builtinModules } from 'node:module';
+import path, { join } from 'path';
+import { rollup, watch } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+import { fileURLToPath } from 'url';
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
+import fsExtra from 'fs-extra/esm';
+
+var EnvService = class {
+};
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs2.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+  writeFile({ filePath, data }) {
+    return new Promise((resolve, reject) => {
+      fs2.writeFile(filePath, data, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  async updateEnvData({
+    key,
+    value,
+    filePath = this.filePath,
+    data
+  }) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (data.match(regex)) {
+      data = data.replace(regex, `${key}=${value}`);
+    } else {
+      data += `
+${key}=${value}`;
+    }
+    await this.writeFile({ filePath, data });
+    console.log(`${key} set to ${value} in ENV file.`);
+    return data;
+  }
+  async getEnvValue(key) {
+    try {
+      const data = await this.readFile(this.filePath);
+      const regex = new RegExp(`^${key}=(.*)$`, "m");
+      const match = data.match(regex);
+      return match?.[1] || null;
+    } catch (err) {
+      console.error(`Error reading ENV value: ${err}`);
+      return null;
+    }
+  }
+  async setEnvValue(key, value) {
+    try {
+      const data = await this.readFile(this.filePath);
+      await this.updateEnvData({ key, value, data });
+    } catch (err) {
+      console.error(`Error writing ENV value: ${err}`);
+    }
+  }
+};
+
+// src/build/fs.ts
+var FileService = class {
+  /**
+   *
+   * @param inputFile the file in the starter files directory to copy
+   * @param outputFilePath the destination path
+   * @param replaceIfExists flag to replace if it exists
+   * @returns
+   */
+  async copyStarterFile(inputFile, outputFilePath, replaceIfExists) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const filePath = path.resolve(__dirname, "..", "starter-files", inputFile);
+    const fileString = fs2__default.readFileSync(filePath, "utf8");
+    if (fs2__default.existsSync(outputFilePath) && !replaceIfExists) {
+      console.log(`${outputFilePath} already exists`);
+      return false;
+    }
+    await fsExtra.outputFile(outputFilePath, fileString);
+    return true;
+  }
+  async setupEnvFile({ dbUrl }) {
+    const envPath = path.join(process.cwd(), ".env.development");
+    await fsExtra.ensureFile(envPath);
+    const fileEnvService = new FileEnvService(envPath);
+    await fileEnvService.setEnvValue("DB_URL", dbUrl);
+  }
+  getFirstExistingFile(files) {
+    for (const f of files) {
+      if (fs2__default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error("Missing required file, checked the following paths: " + files.join(", "));
+  }
+  replaceValuesInFile({
+    filePath,
+    replacements
+  }) {
+    let fileContent = fs2__default.readFileSync(filePath, "utf8");
+    replacements.forEach(({ search, replace }) => {
+      fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs2__default.writeFileSync(filePath, fileContent);
+  }
+};
+
+// src/build/bundle.ts
+function getOptions(inputOptions, platform, root) {
+  const fileService = new FileService();
+  const entry = fileService.getFirstExistingFile([
+    join(root, "src/mastra/index.ts"),
+    join(root, "src/mastra/index.js")
+  ]);
+  const nodeBuiltins = platform === "node" ? builtinModules : [];
+  let nodeResolvePlugin = platform === "node" ? nodeResolve({
+    preferBuiltins: true,
+    exportConditions: ["node", "import", "require"],
+    mainFields: ["module", "main"]
+  }) : nodeResolve({
+    preferBuiltins: false,
+    exportConditions: ["browser", "import", "require"],
+    mainFields: ["module", "main"],
+    browser: true
+  });
+  return {
+    logLevel: "silent",
+    ...inputOptions,
+    treeshake: false,
+    preserveSymlinks: true,
+    external: [
+      ...nodeBuiltins,
+      ...nodeBuiltins.map((builtin) => "node:" + builtin),
+      ...inputOptions.external ?? []
+    ],
+    plugins: [
+      ...inputOptions.plugins ?? [],
+      telemetryFix(),
+      alias({
+        entries: [
+          {
+            find: /^\#server$/,
+            replacement: fileURLToPath(import.meta.resolve("@mastra/deployer/server")).replaceAll("\\", "/")
+          },
+          { find: /^\#mastra$/, replacement: entry.replaceAll("\\", "/") },
+          {
+            find: /^hono\//,
+            replacement: "hono/",
+            customResolver: (id, importer) => {
+              if (!importer?.startsWith("\0virtual")) {
+                return null;
+              }
+              const path2 = import.meta.resolve(id);
+              return fileURLToPath(path2);
+            }
+          }
+        ]
+      }),
+      commonjs({
+        strictRequires: "strict",
+        transformMixedEsModules: true
+        // dynamicRequireTargets: ['node_modules/**/@libsql+win32-*/*'],
+      }),
+      libSqlFix(),
+      // for debugging
+      // {
+      //   name: 'logger',
+      //   // @ts-ignore
+      //   resolveId(id, ...args) {
+      //     console.log({ id, args });
+      //   },
+      // },
+      nodeResolvePlugin,
+      json(),
+      esbuild({
+        include: /\.tsx?$/,
+        target: "node20",
+        platform,
+        minify: false,
+        define: {
+          "process.env.NODE_ENV": JSON.stringify("production")
+        }
+      }),
+      removeDeployer(entry),
+      esbuild({
+        include: entry,
+        target: "node20",
+        platform,
+        minify: false
+      })
+    ].filter(Boolean)
+  };
+}
+async function getBundler(inputOptions, args = {}) {
+  const { platform = "node", dir = process.cwd() } = args;
+  const bundle = await rollup(getOptions(inputOptions, platform, dir));
+  return bundle;
+}
+async function getWatcher(inputOptions, args = {}) {
+  const { platform = "node", dir = process.cwd() } = args;
+  const watcher = watch(getOptions(inputOptions, platform, dir));
+  return watcher;
+}
+async function getInputOptions2(entryFile, platform) {
+  const inputOptions = await getInputOptions(
+    entryFile,
+    {
+      dependencies: /* @__PURE__ */ new Map(),
+      externalDependencies: /* @__PURE__ */ new Set(),
+      invalidChunks: /* @__PURE__ */ new Set()
+    },
+    platform
+  );
+  if (Array.isArray(inputOptions.plugins)) {
+    inputOptions.plugins = inputOptions.plugins.filter(
+      // @ts-ignore
+      (plugin) => !plugin || !plugin?.name || plugin.name !== "node-resolve"
+    );
+    inputOptions.plugins.push(aliasHono());
+  }
+  return inputOptions;
+}
+async function createWatcher(inputOptions, outputOptions) {
+  const watcher = await watch({
+    ...inputOptions,
+    output: {
+      ...outputOptions,
+      format: "esm",
+      entryFileNames: "[name].mjs",
+      chunkFileNames: "[name].mjs"
+    }
+  });
+  return watcher;
+}
+
+export { FileService, createWatcher, getBundler, getInputOptions2 as getInputOptions, getWatcher };

package/dist/chunk-YNXJO2XU.js

@@ -0,0 +1,69 @@
+import * as babel from '@babel/core';
+import babel__default from '@babel/core';
+
+// src/build/plugins/remove-deployer.ts
+function removeDeployer() {
+  const t = babel__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((resolve, reject) => {
+        babel.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeDeployer]
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
+    }
+  };
+}
+
+export { removeDeployer2 as removeDeployer };