@mastra/deployer 0.1.0-alpha.37 → 0.1.0-alpha.38

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/deployer
 
+## 0.1.0-alpha.38
+
+### Minor Changes
+
+- 4d4f6b6: Update deployer
+
+### Patch Changes
+
+- Updated dependencies [4d4f6b6]
+  - @mastra/core@0.2.0-alpha.92
+
 ## 0.1.0-alpha.37
 
 ### Patch Changes

package/dist/build/analyze.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from '@mastra/core';
+
+/**
+ * Main bundle analysis function that orchestrates the three-step process:
+ * 1. Analyze dependencies
+ * 2. Bundle dependencies modules
+ * 3. Validate generated bundles
+ *
+ * This helps identify which dependencies need to be externalized vs bundled.
+ */
+declare function analyzeBundle(entry: string, mastraEntry: string, outputDir: string, platform: 'node' | 'browser', logger: Logger): Promise<{
+    invalidChunks: Set<string>;
+    dependencies: Map<string, string>;
+    externalDependencies: Set<string>;
+}>;
+
+export { analyzeBundle };

package/dist/build/analyze.js

@@ -0,0 +1,2 @@
+export { analyzeBundle } from '../chunk-VBX3JP44.js';
+import '../chunk-YNXJO2XU.js';

package/dist/build/bundler.d.ts

@@ -0,0 +1,14 @@
+import * as rollup from 'rollup';
+import { InputOptions, OutputOptions } from 'rollup';
+import { analyzeBundle } from './analyze.js';
+import '@mastra/core';
+
+declare function getInputOptions(entryFile: string, analyzedBundleInfo: Awaited<ReturnType<typeof analyzeBundle>>, platform: 'node' | 'browser'): Promise<InputOptions>;
+declare function createBundler(inputOptions: InputOptions, outputOptions: Partial<OutputOptions> & {
+    dir: string;
+}): Promise<{
+    write: () => Promise<rollup.RollupOutput>;
+    close: () => Promise<void>;
+}>;
+
+export { createBundler, getInputOptions };

package/dist/build/bundler.js

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

package/dist/build/index.d.ts

@@ -1,57 +1,12 @@
+export { D as Deps, F as FileService, g as getBundler, a as getWatcher } from '../fs-D6g-UVqp.js';
+export { createBundler, getInputOptions as getBundlerInputOptions } from './bundler.js';
 import * as rollup from 'rollup';
-import { InputOptions, Plugin, InputOption } from 'rollup';
-import { MastraBase } from '@mastra/core/base';
+import { InputOptions, OutputOptions } from 'rollup';
+export { analyzeBundle } from './analyze.js';
+import '@mastra/core/base';
+import '@mastra/core';
 
-declare class Deps extends MastraBase {
-    private packageManager;
-    constructor();
-    private findLockFile;
-    private getPackageManager;
-    install({ dir, packages }: {
-        dir?: string;
-        packages?: string[];
-    }): Promise<unknown>;
-    installPackages(packages: string[]): Promise<unknown>;
-    checkDependencies(dependencies: string[]): Promise<string>;
-    getProjectName(): Promise<any>;
-    getPackageVersion(): Promise<string | undefined>;
-    addScriptsToPackageJson(scripts: Record<string, string>): Promise<void>;
-}
+declare function getInputOptions(entryFile: string, platform: 'node' | 'browser'): Promise<InputOptions>;
+declare function createWatcher(inputOptions: InputOptions, outputOptions: OutputOptions): Promise<rollup.RollupWatcher>;
 
-type NormalizedInputOptions = Omit<Partial<InputOptions>, 'plugins' | 'input' | 'external'> & {
-    plugins?: Plugin[];
-    input: InputOption;
-    external?: (string | RegExp)[];
-};
-declare function getBundler(inputOptions: NormalizedInputOptions, args?: {
-    platform?: 'node' | 'browser';
-    dir?: string;
-}): Promise<rollup.RollupBuild>;
-declare function getWatcher(inputOptions: NormalizedInputOptions, args?: {
-    platform?: 'node' | 'browser';
-    dir?: string;
-}): Promise<rollup.RollupWatcher>;
-
-declare class FileService {
-    /**
-     *
-     * @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
-     */
-    copyStarterFile(inputFile: string, outputFilePath: string, replaceIfExists?: boolean): Promise<boolean>;
-    setupEnvFile({ dbUrl }: {
-        dbUrl: string;
-    }): Promise<void>;
-    getFirstExistingFile(files: string[]): string;
-    replaceValuesInFile({ filePath, replacements, }: {
-        filePath: string;
-        replacements: {
-            search: string;
-            replace: string;
-        }[];
-    }): void;
-}
-
-export { Deps, FileService, getBundler, getWatcher };
+export { createWatcher, getInputOptions as getWatcherInputOptions };

package/dist/build/index.js

@@ -1 +1,5 @@
-export { Deps, FileService, getBundler, getWatcher } from '../chunk-PGK75D2J.js';
+export { FileService, createWatcher, getBundler, getWatcher, getInputOptions as getWatcherInputOptions } from '../chunk-NJ6UKWFH.js';
+export { Deps } from '../chunk-Q3WKR6OZ.js';
+export { analyzeBundle } from '../chunk-VBX3JP44.js';
+export { createBundler, getInputOptions as getBundlerInputOptions } from '../chunk-ODEOQDHZ.js';
+import '../chunk-YNXJO2XU.js';

package/dist/bundler/index.d.ts

@@ -0,0 +1,26 @@
+import * as rollup from 'rollup';
+import { InputOptions, OutputOptions } from 'rollup';
+import { MastraBundler } from '@mastra/core/bundler';
+
+declare abstract class Bundler extends MastraBundler {
+    protected analyzeOutputDir: string;
+    protected outputDir: string;
+    constructor(name: string, component?: 'BUNDLER' | 'DEPLOYER');
+    prepare(outputDirectory: string): Promise<void>;
+    writePackageJson(outputDirectory: string, dependencies: Map<string, string>): Promise<void>;
+    protected createBundler(inputOptions: InputOptions, outputOptions: Partial<OutputOptions> & {
+        dir: string;
+    }): Promise<{
+        write: () => Promise<rollup.RollupOutput>;
+        close: () => Promise<void>;
+    }>;
+    protected analyze(entry: string, mastraFile: string, outputDirectory: string): Promise<{
+        invalidChunks: Set<string>;
+        dependencies: Map<string, string>;
+        externalDependencies: Set<string>;
+    }>;
+    protected installDependencies(outputDirectory: string, rootDir?: string): Promise<void>;
+    protected _bundle(serverFile: string, mastraEntryFile: string, outputDirectory: string, bundleLocation?: string): Promise<void>;
+}
+
+export { Bundler };

package/dist/bundler/index.js

@@ -0,0 +1,5 @@
+export { Bundler } from '../chunk-YVQH4O5I.js';
+import '../chunk-Q3WKR6OZ.js';
+import '../chunk-VBX3JP44.js';
+import '../chunk-ODEOQDHZ.js';
+import '../chunk-YNXJO2XU.js';

package/dist/chunk-NJ6UKWFH.js

@@ -0,0 +1,254 @@
+import { aliasHono } from './chunk-VBX3JP44.js';
+import { getInputOptions, telemetryFix, libSqlFix } from './chunk-ODEOQDHZ.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-ODEOQDHZ.js

@@ -0,0 +1,251 @@
+import { removeDeployer } from './chunk-YNXJO2XU.js';
+import alias from '@rollup/plugin-alias';
+import json from '@rollup/plugin-json';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import { fileURLToPath } from 'node:url';
+import { rollup } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+import * as babel from '@babel/core';
+import babel__default from '@babel/core';
+import { currentTarget } from '@neon-rs/load';
+import { familySync, GLIBC } from 'detect-libc';
+import { dirname, join, resolve } from 'path';
+import fsExtra from 'fs-extra/esm';
+import { addNamed } from '@babel/helper-module-imports';
+import { platform } from 'process';
+
+function rewriteLibsqlImport() {
+  const t = babel__default.types;
+  let hasReplaced = false;
+  return {
+    name: "rewrite-libsql-import",
+    visitor: {
+      FunctionDeclaration(path) {
+        if (path.node.id?.name === "requireNative" && !hasReplaced) {
+          hasReplaced = true;
+          const createRequire = 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.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 || dirname(file);
+      let target = currentTarget();
+      if (familySync() == 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.copy(fileToCopy.id, join(outputDirectory, "libsql.node"));
+      }
+    }
+  };
+}
+function getTelemetryMachineFile() {
+  switch (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: resolve(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({
+    preferBuiltins: true,
+    exportConditions: ["node", "import", "require"],
+    mainFields: ["module", "main"]
+  }) : nodeResolve({
+    preferBuiltins: false,
+    exportConditions: ["browser", "import", "require"],
+    mainFields: ["module", "main"],
+    browser: true
+  });
+  return {
+    logLevel: "silent",
+    treeshake: true,
+    preserveSymlinks: true,
+    external: Array.from(analyzedBundleInfo.externalDependencies),
+    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({
+        entries: [
+          {
+            find: /^\#server$/,
+            replacement: fileURLToPath(import.meta.resolve("@mastra/deployer/server")).replaceAll("\\", "/")
+          },
+          { find: /^\#mastra$/, replacement: entryFile.replaceAll("\\", "/") }
+        ]
+      }),
+      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(),
+      esbuild({
+        target: "node20",
+        platform: platform2,
+        minify: false,
+        define: {
+          "process.env.NODE_ENV": JSON.stringify("production")
+        }
+      }),
+      removeDeployer(entryFile),
+      // treeshake unused imports
+      esbuild({
+        include: entryFile,
+        target: "node20",
+        platform: platform2,
+        minify: false
+      })
+    ].filter(Boolean)
+  };
+}
+async function createBundler(inputOptions, outputOptions) {
+  const bundler = await rollup(inputOptions);
+  return {
+    write: () => {
+      return bundler.write({
+        ...outputOptions,
+        format: "esm",
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "[name].mjs"
+      });
+    },
+    close: () => {
+      return bundler.close();
+    }
+  };
+}
+
+export { createBundler, getInputOptions, libSqlFix, telemetryFix };