@mastra/deployer 0.0.0-commonjs-20250227130920

package/dist/templates/instrumentation-template.js

@@ -0,0 +1,86 @@
+import { createLogger } from '@mastra/core/logger'
+import { LibSQLStore } from '@mastra/core/storage/libsql'
+import { OTLPStorageExporter } from '@mastra/core/telemetry'
+import {
+  NodeSDK, getNodeAutoInstrumentations, ATTR_SERVICE_NAME, Resource,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler,
+  AlwaysOnSampler,
+  AlwaysOffSampler,
+  OTLPHttpExporter,
+} from '@mastra/core/telemetry/otel-vendor';
+import { telemetry } from './telemetry-config.mjs'
+
+
+function getSampler(config) {
+  if (!config.sampling) {
+    return new AlwaysOnSampler();
+  }
+
+  if (!config.enabled) {
+    return new AlwaysOffSampler();
+  }
+
+  switch (config.sampling.type) {
+    case 'ratio':
+      return new TraceIdRatioBasedSampler(config.sampling.probability);
+    case 'always_on':
+      return new AlwaysOnSampler();
+    case 'always_off':
+      return new AlwaysOffSampler();
+    case 'parent_based':
+      const rootSampler = new TraceIdRatioBasedSampler(config.sampling.root?.probability || 1.0);
+      return new ParentBasedSampler({ root: rootSampler });
+    default:
+      return new AlwaysOnSampler();
+  }
+
+}
+
+async function getExporter(config) {
+  if (config.export?.type === 'otlp') {
+    return new OTLPHttpExporter({
+      url: config.export.endpoint,
+      headers: config.export.headers,
+    })
+  } else if (config.export?.type === 'custom') {
+    return config.export.exporter
+  } else {
+    const storage = new LibSQLStore({
+      config: {
+        // file lives in ./.mastra/output, and we need to write to ./.mastra/mastra.db
+        url: "file:../mastra.db",
+      },
+    })
+    await storage.init()
+
+    return new OTLPStorageExporter({
+      logger: createLogger({
+        name: 'telemetry',
+        level: 'silent',
+      }),
+      storage,
+    })
+  }
+}
+
+const sampler = getSampler(telemetry);
+const exporter = await getExporter(telemetry);
+
+const sdk = new NodeSDK({
+  resource: new Resource({
+    [ATTR_SERVICE_NAME]: telemetry.serviceName || 'default-service',
+  }),
+  sampler,
+  traceExporter: exporter,
+  instrumentations: [getNodeAutoInstrumentations()],
+});
+
+sdk.start();
+
+// gracefully shut down the SDK on process exit
+process.on('SIGTERM', () => {
+  sdk.shutdown().catch(() => {
+    // do nothing
+  })
+});

package/eslint.config.js

@@ -0,0 +1,6 @@
+import { createConfig } from '@internal/lint/eslint';
+
+const config = await createConfig();
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...config];

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@mastra/deployer",
+  "version": "0.0.0-commonjs-20250227130920",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./server": {
+      "import": {
+        "types": "./dist/server/index.d.ts",
+        "default": "./dist/server/index.js"
+      },
+      "require": {
+        "types": "./dist/server/index.d.cts",
+        "default": "./dist/server/index.cjs"
+      }
+    },
+    "./build": {
+      "import": {
+        "types": "./dist/build/index.d.ts",
+        "default": "./dist/build/index.js"
+      },
+      "require": {
+        "types": "./dist/build/index.d.cts",
+        "default": "./dist/build/index.cjs"
+      }
+    },
+    "./bundler": {
+      "import": {
+        "types": "./dist/bundler/index.d.ts",
+        "default": "./dist/bundler/index.js"
+      },
+      "require": {
+        "types": "./dist/bundler/index.d.cts",
+        "default": "./dist/bundler/index.cjs"
+      }
+    },
+    "./analyze": {
+      "import": {
+        "types": "./dist/build/analyze.d.ts",
+        "default": "./dist/build/analyze.js"
+      },
+      "require": {
+        "types": "./dist/build/analyze.d.cts",
+        "default": "./dist/build/analyze.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.26.7",
+    "@babel/helper-module-imports": "^7.25.9",
+    "@neon-rs/load": "^0.1.82",
+    "@rollup/plugin-alias": "^5.1.1",
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-virtual": "^3.0.2",
+    "builtins": "^5.1.0",
+    "detect-libc": "^2.0.3",
+    "dotenv": "^16.4.7",
+    "esbuild": "^0.24.2",
+    "fs-extra": "^11.2.0",
+    "hono": "^4.6.17",
+    "rollup": "^4.30.1",
+    "rollup-plugin-esbuild": "^6.1.1",
+    "rollup-plugin-node-externals": "^8.0.0",
+    "zod": "^3.24.1",
+    "@mastra/core": "^0.0.0-commonjs-20250227130920"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.13.7",
+    "@hono/swagger-ui": "^0.5.0",
+    "@microsoft/api-extractor": "^7.49.2",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__helper-module-imports": "^7.18.3",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.13.1",
+    "concurrently": "^9.1.0",
+    "hono-openapi": "^0.4.3",
+    "rollup-plugin-visualizer": "^5.14.0",
+    "superjson": "^2.2.2",
+    "tsup": "^8.3.6",
+    "type-fest": "^4.30.0",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8",
+    "zod-to-json-schema": "^3.24.1",
+    "eslint": "^9.20.1",
+    "@internal/lint": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/build/index.ts src/server/index.ts src/build/bundler.ts src/build/analyze.ts src/bundler/index.ts --format esm,cjs --clean --experimental-dts --treeshake --publicDir",
+    "build:watch": "pnpm build --watch",
+    "pull:openapispec": "node src/server/openapi.script.js",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
+}

package/public/templates/instrumentation-template.js

@@ -0,0 +1,86 @@
+import { createLogger } from '@mastra/core/logger'
+import { LibSQLStore } from '@mastra/core/storage/libsql'
+import { OTLPStorageExporter } from '@mastra/core/telemetry'
+import {
+  NodeSDK, getNodeAutoInstrumentations, ATTR_SERVICE_NAME, Resource,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler,
+  AlwaysOnSampler,
+  AlwaysOffSampler,
+  OTLPHttpExporter,
+} from '@mastra/core/telemetry/otel-vendor';
+import { telemetry } from './telemetry-config.mjs'
+
+
+function getSampler(config) {
+  if (!config.sampling) {
+    return new AlwaysOnSampler();
+  }
+
+  if (!config.enabled) {
+    return new AlwaysOffSampler();
+  }
+
+  switch (config.sampling.type) {
+    case 'ratio':
+      return new TraceIdRatioBasedSampler(config.sampling.probability);
+    case 'always_on':
+      return new AlwaysOnSampler();
+    case 'always_off':
+      return new AlwaysOffSampler();
+    case 'parent_based':
+      const rootSampler = new TraceIdRatioBasedSampler(config.sampling.root?.probability || 1.0);
+      return new ParentBasedSampler({ root: rootSampler });
+    default:
+      return new AlwaysOnSampler();
+  }
+
+}
+
+async function getExporter(config) {
+  if (config.export?.type === 'otlp') {
+    return new OTLPHttpExporter({
+      url: config.export.endpoint,
+      headers: config.export.headers,
+    })
+  } else if (config.export?.type === 'custom') {
+    return config.export.exporter
+  } else {
+    const storage = new LibSQLStore({
+      config: {
+        // file lives in ./.mastra/output, and we need to write to ./.mastra/mastra.db
+        url: "file:../mastra.db",
+      },
+    })
+    await storage.init()
+
+    return new OTLPStorageExporter({
+      logger: createLogger({
+        name: 'telemetry',
+        level: 'silent',
+      }),
+      storage,
+    })
+  }
+}
+
+const sampler = getSampler(telemetry);
+const exporter = await getExporter(telemetry);
+
+const sdk = new NodeSDK({
+  resource: new Resource({
+    [ATTR_SERVICE_NAME]: telemetry.serviceName || 'default-service',
+  }),
+  sampler,
+  traceExporter: exporter,
+  instrumentations: [getNodeAutoInstrumentations()],
+});
+
+sdk.start();
+
+// gracefully shut down the SDK on process exit
+process.on('SIGTERM', () => {
+  sdk.shutdown().catch(() => {
+    // do nothing
+  })
+});

package/src/build/analyze.ts

@@ -0,0 +1,279 @@
+import type { Logger } from '@mastra/core';
+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, type Plugin } from 'rollup';
+import esbuild from 'rollup-plugin-esbuild';
+
+import { isNodeBuiltin } from './isNodeBuiltin';
+import { aliasHono } from './plugins/hono-alias';
+import { pino } from './plugins/pino';
+import { removeDeployer } from './plugins/remove-deployer';
+
+/**
+ * Analyzes the entry file to identify dependencies that need optimization.
+ * This is the first step of the bundle analysis process.
+ *
+ * @param entry - The entry file path or content
+ * @param mastraEntry - The mastra entry point
+ * @param isVirtualFile - Whether the entry is a virtual file (content string) or a file path
+ * @param platform - Target platform (node or browser)
+ * @param logger - Logger instance for debugging
+ * @returns Map of dependencies to optimize with their exported bindings
+ */
+async function analyze(
+  entry: string,
+  mastraEntry: string,
+  isVirtualFile: boolean,
+  platform: 'node' | 'browser',
+  logger: 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: string) {
+          if (id === '#server') {
+            return fileURLToPath(import.meta.resolve('@mastra/deployer/server')).replaceAll('\\', '/');
+          }
+          if (id === '#mastra') {
+            return mastraEntry.replaceAll('\\', '/');
+          }
+        },
+      } satisfies Plugin,
+      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;
+}
+
+/**
+ * Bundles vendor dependencies identified in the analysis step.
+ * Creates virtual modules for each dependency and bundles them using rollup.
+ *
+ * @param depsToOptimize - Map of dependencies with their exports from analyze step
+ * @param outputDir - Directory where bundled files will be written
+ * @param logger - Logger instance for debugging
+ * @returns Object containing bundle output and reference map for validation
+ */
+async function bundleExternals(depsToOptimize: Map<string, string[]>, outputDir: string, logger: Logger) {
+  logger.info('Optimizing dependencies...');
+  logger.debug(
+    `${Array.from(depsToOptimize.keys())
+      .map(key => `- ${key}`)
+      .join('\n')}`,
+  );
+
+  const reverseVirtualReferenceMap = new Map<string, string>();
+  const virtualDependencies = new Map();
+  for (const [dep, exports] of depsToOptimize.entries()) {
+    const name = dep.replaceAll('/', '-');
+    reverseVirtualReferenceMap.set(name, dep);
+
+    const virtualFile: string[] = [];
+    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;
+      },
+      {} as Record<string, string>,
+    ),
+    // 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;
+          },
+          {} as Record<string, string>,
+        ),
+      ),
+      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 };
+}
+
+/**
+ * Validates the bundled output by attempting to import each generated module.
+ * Tracks invalid chunks and external dependencies that couldn't be bundled.
+ *
+ * @param output - Bundle output from rollup
+ * @param reverseVirtualReferenceMap - Map to resolve virtual module names back to original deps
+ * @param outputDir - Directory containing the bundled files
+ * @param logger - Logger instance for debugging
+ * @returns Analysis result containing invalid chunks and dependency mappings
+ */
+async function validateOutput(
+  output: any[],
+  reverseVirtualReferenceMap: Map<string, string>,
+  outputDir: string,
+  logger: Logger,
+) {
+  const result = {
+    invalidChunks: new Set<string>(),
+    dependencies: new Map<string, string>(),
+    externalDependencies: new Set<string>(),
+  };
+
+  //const internalFiles = new Set<string>(output.map(file => file.fileName));
+
+  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)!);
+      }
+
+      // we might need this on other projects but not sure so let's keep it commented out for now
+      // console.log(file.fileName, file.isEntry, file.isDynamicEntry, err);
+      // result.invalidChunks.add(file.fileName);
+      // const externalImports = excludeInternalDeps(file.imports.filter(file => !internalFiles.has(file)));
+      // externalImports.push(...excludeInternalDeps(file.dynamicImports.filter(file => !internalFiles.has(file))));
+      // for (const externalImport of externalImports) {
+      //   result.externalDependencies.add(externalImport);
+      // }
+
+      // if (reverseVirtualReferenceMap.has(file.name)) {
+      //   result.externalDependencies.add(reverseVirtualReferenceMap.get(file.name)!);
+      // }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 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.
+ */
+export async function analyzeBundle(
+  entry: string,
+  mastraEntry: string,
+  outputDir: string,
+  platform: 'node' | 'browser',
+  logger: 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;
+}

package/src/build/babel/fix-libsql.ts

@@ -0,0 +1,41 @@
+import babel from '@babel/core';
+import { addNamed } from '@babel/helper-module-imports';
+
+export function rewriteLibsqlImport() {
+  const t = babel.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')])),
+              ]),
+            ),
+          );
+        }
+      },
+    },
+  } as babel.PluginObj;
+}

package/src/build/babel/get-deployer.ts

@@ -0,0 +1,54 @@
+import babel from '@babel/core';
+
+export function removeAllExceptDeployer() {
+  let mastraClass: string | null = null;
+
+  const t = babel.types;
+
+  return {
+    name: 'remove-all-except-deployer',
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path) {
+          path.remove();
+        },
+      },
+      ImportDeclaration(path) {
+        if (
+          (path.node.source.value === '@mastra/core' || path.node.source.value === '@mastra/core/mastra') &&
+          path.node.specifiers
+        ) {
+          mastraClass =
+            path.node.specifiers.find(
+              // @ts-ignore - no need to type
+              p => p.imported?.name === 'Mastra',
+            )?.local?.name ?? null;
+        }
+      },
+      NewExpression(path) {
+        if (mastraClass && (path.node.callee as babel.types.Identifier).name === mastraClass) {
+          // @ts-ignore
+          const deployer = path.node.arguments[0]?.properties?.find(
+            // @ts-ignore
+            prop => prop.key.name === 'deployer',
+          );
+
+          const programPath = path.scope.getProgramParent().path;
+          if (!deployer || !programPath) {
+            return;
+          }
+
+          // add the deployer export
+          const exportDeclaration = t.exportNamedDeclaration(
+            t.variableDeclaration('const', [t.variableDeclarator(t.identifier('deployer'), deployer.value)]),
+            [],
+          );
+
+          // @ts-ignore
+          programPath.node.body.push(exportDeclaration);
+        }
+      },
+    },
+  } as babel.PluginObj;
+}