@mastra/deployer 0.10.13 → 0.10.15-alpha.0

package/dist/build/analyze.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkXKH6F4NE_cjs = require('../chunk-XKH6F4NE.cjs');
+
+
+
+Object.defineProperty(exports, "analyzeBundle", {
+  enumerable: true,
+  get: function () { return chunkXKH6F4NE_cjs.analyzeBundle; }
+});

package/dist/build/analyze.d.cts

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

package/dist/build/analyze.d.ts

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

package/dist/build/analyze.js

@@ -0,0 +1 @@
+export { analyzeBundle } from '../chunk-UYQZMNZL.js';

package/dist/build/bundler.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var chunkD2DCFCLH_cjs = require('../chunk-D2DCFCLH.cjs');
+
+
+
+Object.defineProperty(exports, "createBundler", {
+  enumerable: true,
+  get: function () { return chunkD2DCFCLH_cjs.createBundler; }
+});
+Object.defineProperty(exports, "getInputOptions", {
+  enumerable: true,
+  get: function () { return chunkD2DCFCLH_cjs.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 @@
+export { createBundler, getInputOptions } from '../chunk-TIC2KT3M.js';

package/dist/build/index.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var chunkFK2WUSEN_cjs = require('../chunk-FK2WUSEN.cjs');
+var chunkM2VZQFTW_cjs = require('../chunk-M2VZQFTW.cjs');
+var chunkXKH6F4NE_cjs = require('../chunk-XKH6F4NE.cjs');
+var chunkD2DCFCLH_cjs = require('../chunk-D2DCFCLH.cjs');
+var chunkKCP5ITLV_cjs = require('../chunk-KCP5ITLV.cjs');
+
+
+
+Object.defineProperty(exports, "createWatcher", {
+  enumerable: true,
+  get: function () { return chunkFK2WUSEN_cjs.createWatcher; }
+});
+Object.defineProperty(exports, "getServerOptions", {
+  enumerable: true,
+  get: function () { return chunkFK2WUSEN_cjs.getServerOptions; }
+});
+Object.defineProperty(exports, "getWatcherInputOptions", {
+  enumerable: true,
+  get: function () { return chunkFK2WUSEN_cjs.getInputOptions; }
+});
+Object.defineProperty(exports, "writeTelemetryConfig", {
+  enumerable: true,
+  get: function () { return chunkM2VZQFTW_cjs.writeTelemetryConfig; }
+});
+Object.defineProperty(exports, "analyzeBundle", {
+  enumerable: true,
+  get: function () { return chunkXKH6F4NE_cjs.analyzeBundle; }
+});
+Object.defineProperty(exports, "getBundlerOptions", {
+  enumerable: true,
+  get: function () { return chunkXKH6F4NE_cjs.getBundlerOptions; }
+});
+Object.defineProperty(exports, "createBundler", {
+  enumerable: true,
+  get: function () { return chunkD2DCFCLH_cjs.createBundler; }
+});
+Object.defineProperty(exports, "getBundlerInputOptions", {
+  enumerable: true,
+  get: function () { return chunkD2DCFCLH_cjs.getInputOptions; }
+});
+Object.defineProperty(exports, "Deps", {
+  enumerable: true,
+  get: function () { return chunkKCP5ITLV_cjs.Deps; }
+});
+Object.defineProperty(exports, "FileService", {
+  enumerable: true,
+  get: function () { return chunkKCP5ITLV_cjs.FileService; }
+});

package/dist/build/index.d.cts

@@ -0,0 +1,10 @@
+export { createBundler_alias_1 as createBundler } from '../_tsup-dts-rollup.cjs';
+export { getBundlerInputOptions } from '../_tsup-dts-rollup.cjs';
+export { createWatcher } from '../_tsup-dts-rollup.cjs';
+export { getWatcherInputOptions } from '../_tsup-dts-rollup.cjs';
+export { analyzeBundle_alias_1 as analyzeBundle } from '../_tsup-dts-rollup.cjs';
+export { FileService_alias_1 as FileService } from '../_tsup-dts-rollup.cjs';
+export { Deps_alias_1 as Deps } from '../_tsup-dts-rollup.cjs';
+export { writeTelemetryConfig } from '../_tsup-dts-rollup.cjs';
+export { getServerOptions } from '../_tsup-dts-rollup.cjs';
+export { getBundlerOptions_alias_1 as getBundlerOptions } from '../_tsup-dts-rollup.cjs';

package/dist/build/index.d.ts

@@ -0,0 +1,10 @@
+export { createBundler_alias_1 as createBundler } from '../_tsup-dts-rollup.js';
+export { getBundlerInputOptions } from '../_tsup-dts-rollup.js';
+export { createWatcher } from '../_tsup-dts-rollup.js';
+export { getWatcherInputOptions } from '../_tsup-dts-rollup.js';
+export { analyzeBundle_alias_1 as analyzeBundle } from '../_tsup-dts-rollup.js';
+export { FileService_alias_1 as FileService } from '../_tsup-dts-rollup.js';
+export { Deps_alias_1 as Deps } from '../_tsup-dts-rollup.js';
+export { writeTelemetryConfig } from '../_tsup-dts-rollup.js';
+export { getServerOptions } from '../_tsup-dts-rollup.js';
+export { getBundlerOptions_alias_1 as getBundlerOptions } from '../_tsup-dts-rollup.js';

package/dist/build/index.js

@@ -0,0 +1,5 @@
+export { createWatcher, getServerOptions, getInputOptions as getWatcherInputOptions } from '../chunk-D6736SJL.js';
+export { writeTelemetryConfig } from '../chunk-ENT5RDOI.js';
+export { analyzeBundle, getBundlerOptions } from '../chunk-UYQZMNZL.js';
+export { createBundler, getInputOptions as getBundlerInputOptions } from '../chunk-TIC2KT3M.js';
+export { Deps, FileService } from '../chunk-GPD54HBC.js';

package/dist/bundler/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkYFMAWUII_cjs = require('../chunk-YFMAWUII.cjs');
+
+
+
+Object.defineProperty(exports, "Bundler", {
+  enumerable: true,
+  get: function () { return chunkYFMAWUII_cjs.Bundler; }
+});

package/dist/bundler/index.d.cts

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

package/dist/bundler/index.d.ts

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

package/dist/bundler/index.js

@@ -0,0 +1 @@
+export { Bundler } from '../chunk-HJGC75ZR.js';

package/dist/chunk-54KOF3NB.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+var babel = require('@babel/core');
+var fs = require('fs');
+var path = require('path');
+var typescriptPaths = require('typescript-paths');
+
+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 babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// src/build/plugins/remove-deployer.ts
+function removeDeployer() {
+  const t = babel__namespace.default.types;
+  return {
+    name: "remove-deployer",
+    visitor: {
+      NewExpression(path2, state) {
+        const varDeclaratorPath = path2.findParent((path3) => t.isVariableDeclarator(path3.node));
+        if (!varDeclaratorPath) {
+          return;
+        }
+        const parentNode = path2.parentPath.node;
+        if (!t.isVariableDeclarator(parentNode) || !t.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
+          return;
+        }
+        if (!state.hasReplaced) {
+          state.hasReplaced = true;
+          const newMastraObj = t.cloneNode(path2.node);
+          if (t.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.[0]) {
+            const deployer = newMastraObj.arguments[0].properties.find(
+              (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "deployer"
+            );
+            if (!deployer) {
+              return;
+            }
+            newMastraObj.arguments[0].properties = newMastraObj.arguments[0].properties.filter(
+              (prop) => prop !== deployer
+            );
+            if (t.isObjectProperty(deployer) && t.isIdentifier(deployer.value)) {
+              const deployerBinding = state.file.scope.getBinding(deployer.value.name);
+              if (deployerBinding) {
+                deployerBinding?.path?.parentPath?.remove();
+              }
+            }
+            path2.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__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeDeployer]
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
+    }
+  };
+}
+var PLUGIN_NAME = "tsconfig-paths";
+function tsConfigPaths({ tsConfigPath, respectCoreModule } = {}) {
+  let handler;
+  return {
+    name: PLUGIN_NAME,
+    buildStart() {
+      handler = typescriptPaths.createHandler({
+        log: () => {
+        },
+        tsConfigPath,
+        respectCoreModule,
+        falllback: (moduleName) => fs__default.default.existsSync(moduleName)
+      });
+      return;
+    },
+    async resolveId(request, importer, options) {
+      if (!importer || request.startsWith("\0")) {
+        return null;
+      }
+      const moduleName = handler?.(request, path.normalize(importer));
+      if (!moduleName) {
+        return this.resolve(request, importer, { skipSelf: true, ...options });
+      }
+      if (!path__default.default.extname(moduleName)) {
+        return this.resolve(moduleName, importer, { skipSelf: true, ...options });
+      }
+      return moduleName;
+    }
+  };
+}
+
+exports.removeDeployer = removeDeployer2;
+exports.tsConfigPaths = tsConfigPaths;

package/dist/chunk-6QMONK4A.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/chunk-C4JT7CIH.js

@@ -0,0 +1 @@
+

package/dist/chunk-D2DCFCLH.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+var chunk54KOF3NB_cjs = require('./chunk-54KOF3NB.cjs');
+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');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+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);
+
+async function getInputOptions(entryFile, analyzedBundleInfo, platform, env = { "process.env.NODE_ENV": JSON.stringify("production") }) {
+  let nodeResolvePlugin = platform === "node" ? nodeResolve__default.default({
+    preferBuiltins: true,
+    exportConditions: ["node"]
+  }) : nodeResolve__default.default({
+    preferBuiltins: false,
+    browser: true
+  });
+  const externalsCopy = /* @__PURE__ */ new Set();
+  for (const external of analyzedBundleInfo.externalDependencies) {
+    if (external.startsWith("@")) {
+      const [scope, name] = external.split("/", 3);
+      externalsCopy.add(`${scope}/${name}`);
+      externalsCopy.add(`${scope}/${name}/*`);
+    } else {
+      externalsCopy.add(external);
+      externalsCopy.add(`${external}/*`);
+    }
+  }
+  const externals = Array.from(externalsCopy);
+  const normalizedEntryFile = entryFile.replaceAll("\\", "/");
+  return {
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    treeshake: "smallest",
+    preserveSymlinks: true,
+    external: externals,
+    plugins: [
+      chunk54KOF3NB_cjs.tsConfigPaths(),
+      {
+        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\/server\/(.*)/,
+            replacement: `@mastra/server/$1`,
+            customResolver: (id) => {
+              if (id.startsWith("@mastra/server")) {
+                return {
+                  id: url.fileURLToPath(undefined(id))
+                };
+              }
+            }
+          },
+          { find: /^\#mastra$/, replacement: normalizedEntryFile }
+        ]
+      }),
+      {
+        name: "tools-rewriter",
+        resolveId(id) {
+          if (id === "#tools") {
+            return {
+              id: "./tools.mjs",
+              external: true
+            };
+          }
+        }
+      },
+      esbuild__default.default({
+        target: "node20",
+        platform,
+        minify: false,
+        define: env
+      }),
+      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(),
+      chunk54KOF3NB_cjs.removeDeployer(entryFile),
+      // treeshake unused imports
+      esbuild__default.default({
+        include: entryFile,
+        target: "node20",
+        platform,
+        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/chunk-D6736SJL.js

@@ -0,0 +1,209 @@
+import { aliasHono, recursiveRemoveNonReferencedNodes, removeAllOptionsFromMastraExcept } from './chunk-UYQZMNZL.js';
+import { getInputOptions } from './chunk-TIC2KT3M.js';
+import { tsConfigPaths } from './chunk-Z544XXXK.js';
+import { watch, rollup } from 'rollup';
+import { extname, dirname } from 'path';
+import resolveFrom from 'resolve-from';
+import { builtinModules } from 'module';
+import * as babel from '@babel/core';
+import esbuild from 'rollup-plugin-esbuild';
+import commonjs from '@rollup/plugin-commonjs';
+
+function isBuiltinModule(specifier) {
+  return builtinModules.includes(specifier) || specifier.startsWith("node:") || builtinModules.includes(specifier.replace(/^node:/, ""));
+}
+function safeResolve(id, importer) {
+  try {
+    return resolveFrom(importer, id);
+  } catch {
+    return null;
+  }
+}
+function getPackageName(id) {
+  const parts = id.split("/");
+  if (id.startsWith("@")) {
+    return parts.slice(0, 2).join("/");
+  }
+  return parts[0];
+}
+function nodeModulesExtensionResolver() {
+  return {
+    name: "node-modules-extension-resolver",
+    resolveId(id, importer) {
+      if (id.startsWith(".") || id.startsWith("/") || !importer) {
+        return null;
+      }
+      if (isBuiltinModule(id)) {
+        return null;
+      }
+      if (id.startsWith("@") && id.split("/").length === 2) {
+        return null;
+      }
+      if (!id.startsWith("@") && id.split("/").length === 1) {
+        return null;
+      }
+      const foundExt = extname(id);
+      if (foundExt) {
+        return null;
+      }
+      try {
+        const resolved = import.meta.resolve(id);
+        if (!extname(resolved)) {
+          throw new Error(`Cannot resolve ${id} from ${importer}`);
+        }
+        return null;
+      } catch (e) {
+        for (const ext of [".mjs", ".js", ".cjs"]) {
+          const resolved = safeResolve(id + ext, importer);
+          if (resolved) {
+            const pkgName = getPackageName(id);
+            if (!pkgName) {
+              return null;
+            }
+            const pkgJsonPath = safeResolve(`${pkgName}/package.json`, importer);
+            if (!pkgJsonPath) {
+              return null;
+            }
+            const newImportWithExtension = resolved.replace(dirname(pkgJsonPath), pkgName);
+            return {
+              id: newImportWithExtension,
+              external: true
+            };
+          }
+        }
+      }
+      return null;
+    }
+  };
+}
+
+// src/build/watcher.ts
+async function getInputOptions2(entryFile, platform, env) {
+  const inputOptions = await getInputOptions(
+    entryFile,
+    {
+      dependencies: /* @__PURE__ */ new Map(),
+      externalDependencies: /* @__PURE__ */ new Set(),
+      invalidChunks: /* @__PURE__ */ new Set()
+    },
+    platform,
+    env
+  );
+  if (Array.isArray(inputOptions.plugins)) {
+    inputOptions.plugins = inputOptions.plugins.filter(
+      // @ts-ignore
+      (plugin) => !plugin || !plugin?.name || plugin.name !== "node-resolve"
+    );
+    inputOptions.plugins.push(aliasHono());
+    inputOptions.plugins.push(nodeModulesExtensionResolver());
+  }
+  return inputOptions;
+}
+async function createWatcher(inputOptions, outputOptions) {
+  const watcher = await watch({
+    ...inputOptions,
+    output: {
+      ...outputOptions,
+      format: "esm",
+      entryFileNames: "[name].mjs",
+      chunkFileNames: "[name].mjs"
+    }
+  });
+  return watcher;
+}
+
+// src/build/babel/remove-all-options-server.ts
+function removeAllOptionsExceptServer(result) {
+  return removeAllOptionsFromMastraExcept(result, "server");
+}
+function getServerOptionsBundler(entryFile, result) {
+  return rollup({
+    logLevel: "silent",
+    input: {
+      "server-config": entryFile
+    },
+    treeshake: "smallest",
+    plugins: [
+      tsConfigPaths(),
+      // transpile typescript to something we understand
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      commonjs({
+        extensions: [".js", ".ts"],
+        strictRequires: "strict",
+        transformMixedEsModules: true,
+        ignoreTryCatch: false
+      }),
+      {
+        name: "get-server-config",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return new Promise((resolve, reject) => {
+            babel.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllOptionsExceptServer(result)]
+              },
+              (err, result2) => {
+                if (err) {
+                  return reject(err);
+                }
+                resolve({
+                  code: result2.code,
+                  map: result2.map
+                });
+              }
+            );
+          });
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "cleanup",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return recursiveRemoveNonReferencedNodes(code);
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+}
+async function getServerOptions(entryFile, outputDir) {
+  const result = {
+    hasCustomConfig: false
+  };
+  const bundle = await getServerOptionsBundler(entryFile, result);
+  await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs",
+    sourcemap: true
+  });
+  if (result.hasCustomConfig) {
+    return (await import(`file:${outputDir}/server-config.mjs`)).server;
+  }
+  return null;
+}
+
+export { createWatcher, getInputOptions2 as getInputOptions, getServerOptions };