@cedarjs/cli 4.2.1-next.0 → 4.2.1-next.269

package/dist/lib/merge/strategy.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import uniqWith from "lodash/uniqWith.js";
 import { nodeIs, sieve } from "./algorithms.js";
-const OPAQUE_UID_TAG = "RW_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
+const OPAQUE_UID_TAG = "CEDAR_MERGE_OPAQUE_UID_Q2xldmVyIHlvdSEgSGF2ZSBhIGNvb2tpZS4=";
 function requireSameType(base, ext) {
   if (base.path.type !== ext.path.type) {
     throw new Error(
@@ -17,9 +17,21 @@ function requireStrategyExists(base, _ext, strategy, strategyName) {
   }
 }
 const strictEquality = (lhs, rhs) => lhs === rhs;
-const byName = (lhs, rhs) => lhs.name === rhs.name;
-const byKeyName = (lhs, rhs) => lhs.key.name === rhs.key.name;
-const byValue = (lhs, rhs) => lhs.value === rhs.value;
+function hasName(v) {
+  return typeof v === "object" && v !== null && "name" in v;
+}
+function hasKey(v) {
+  return typeof v === "object" && v !== null && "key" in v;
+}
+function hasKeyName(v) {
+  return hasKey(v) && hasName(v.key);
+}
+function hasValue(v) {
+  return typeof v === "object" && v !== null && "value" in v;
+}
+const byName = (lhs, rhs) => hasName(lhs) && hasName(rhs) && lhs.name === rhs.name;
+const byKeyName = (lhs, rhs) => hasKeyName(lhs) && hasKeyName(rhs) && lhs.key.name === rhs.key.name;
+const byValue = (lhs, rhs) => hasValue(lhs) && hasValue(rhs) && lhs.value === rhs.value;
 function defaultEquality(baseContainer, extContainer) {
   const sample = baseContainer.length && baseContainer[0] || extContainer.length && extContainer[0];
   const defaults = {
@@ -30,14 +42,13 @@ function defaultEquality(baseContainer, extContainer) {
     ObjectProperty: byKeyName,
     StringLiteral: byValue
   };
-  return sample && sample.type in defaults ? defaults[sample.type] : strictEquality;
+  return sample && typeof sample === "object" && "type" in sample && typeof sample.type === "string" && sample.type in defaults ? defaults[sample.type] : strictEquality;
 }
-function opaquely(strategy) {
-  strategy[OPAQUE_UID_TAG] = true;
-  return strategy;
+function opaquely(reducer) {
+  return Object.assign(reducer, { [OPAQUE_UID_TAG]: true });
 }
-function isOpaque(strategy) {
-  return strategy[OPAQUE_UID_TAG] === true;
+function isOpaque(fn) {
+  return OPAQUE_UID_TAG in fn && fn[OPAQUE_UID_TAG] === true;
 }
 const keepBase = opaquely(() => {
 });
@@ -47,20 +58,36 @@ const keepBoth = opaquely((base, ext) => {
 const keepExtension = opaquely((base, ext) => {
   base.path.replaceWith(ext.path);
 });
-const keepBothStatementParents = opaquely((base, ext) => {
-  base.path.getStatementParent().insertAfter(ext.path.getStatementParent().node);
-});
+const keepBothStatementParents = opaquely(
+  (base, ext) => {
+    const extParent = ext.path.getStatementParent();
+    if (extParent) {
+      base.path.getStatementParent()?.insertAfter(extParent.node);
+    }
+  }
+);
 const interleaveStrategy = {
-  ImportDeclaration(baseImport, extImport) {
-    const baseSpecs = baseImport.specifiers;
-    const extSpecs = extImport.specifiers;
-    const importSpecifierEquality = (lhs, rhs) => lhs.type === rhs.type && lhs.imported?.name === rhs.imported?.name && lhs.local?.name == rhs.local?.name;
+  ImportDeclaration(base, ext) {
+    if (!t.isImportDeclaration(base) || !t.isImportDeclaration(ext)) {
+      return;
+    }
+    const baseSpecs = base.specifiers;
+    const extSpecs = ext.specifiers;
+    const importSpecifierEquality = (lhs, rhs) => {
+      if (lhs.type !== rhs.type) {
+        return false;
+      }
+      if (lhs.type === "ImportSpecifier" && rhs.type === "ImportSpecifier") {
+        return lhs.imported.type === "Identifier" && rhs.imported.type === "Identifier" && lhs.imported.name === rhs.imported.name && lhs.local?.name === rhs.local?.name;
+      }
+      return lhs.local?.name === rhs.local?.name;
+    };
     const uniqueSpecifiersOfType = (type) => uniqWith(
       [...baseSpecs, ...extSpecs].filter(nodeIs(type)),
       importSpecifierEquality
     );
     if (!baseSpecs.length !== !extSpecs.length) {
-      return keepBothStatementParents(baseImport, extImport);
+      return keepBothStatementParents(base, ext);
     }
     const defaultPosition = (specs) => specs.some(nodeIs("ImportDefaultSpecifier")) ? -1 : 0;
     const namespacePosition = (specs) => specs.some(nodeIs("ImportNamespaceSpecifier")) || specs.some(nodeIs("ImportSpecifier")) ? -1 : specs.length;
@@ -70,10 +97,10 @@ const interleaveStrategy = {
       [uniqueSpecifiersOfType("ImportNamespaceSpecifier"), namespacePosition],
       [uniqueSpecifiersOfType("ImportSpecifier"), importPosition]
     );
-    baseImport.specifiers = firstSpecifierList;
+    base.specifiers = firstSpecifierList;
     if (rest.length) {
-      baseImport.path.insertAfter(
-        rest.map((specs) => t.importDeclaration(specs, baseImport.source))
+      base.path.insertAfter(
+        rest.map((specs) => t.importDeclaration(specs, base.source))
       );
     }
   }
@@ -81,47 +108,70 @@ const interleaveStrategy = {
 function interleave(base, ext) {
   requireSameType(base, ext);
   requireStrategyExists(base, ext, interleaveStrategy, "interleave");
-  return interleaveStrategy[base.path.type](base, ext);
+  interleaveStrategy[base.path.type]?.(base, ext);
 }
 const concatStrategy = {
   ArrayExpression(base, ext) {
+    if (!t.isArrayExpression(base) || !t.isArrayExpression(ext)) {
+      return;
+    }
     base.elements = [...base.elements, ...ext.elements];
   },
   ObjectExpression(base, ext) {
+    if (!t.isObjectExpression(base) || !t.isObjectExpression(ext)) {
+      return;
+    }
     base.properties = [...base.properties, ...ext.properties];
   },
   StringLiteral(base, ext) {
+    if (!t.isStringLiteral(base) || !t.isStringLiteral(ext)) {
+      return;
+    }
     base.value = base.value.concat(ext.value);
   }
 };
 function concat(base, ext) {
   requireSameType(base, ext);
   requireStrategyExists(base, ext, concatStrategy, "concat");
-  return concatStrategy[base.path.type](base, ext);
+  concatStrategy[base.path.type]?.(base, ext);
 }
 const concatUniqueStrategy = {
   ArrayExpression(base, ext, eq) {
-    eq ||= defaultEquality(base.elements, ext.elements);
-    base.elements = uniqWith([...base.elements, ...ext.elements], eq);
+    if (!t.isArrayExpression(base) || !t.isArrayExpression(ext)) {
+      return;
+    }
+    const equalFn = eq ?? defaultEquality(base.elements, ext.elements);
+    base.elements = uniqWith([...base.elements, ...ext.elements], equalFn);
   },
   ObjectExpression(base, ext, eq) {
-    eq ||= defaultEquality(base.properties, ext.properties);
-    base.properties = uniqWith([...base.properties, ...ext.properties], eq);
+    if (!t.isObjectExpression(base) || !t.isObjectExpression(ext)) {
+      return;
+    }
+    const equalFn = eq ?? defaultEquality(base.properties, ext.properties);
+    base.properties = uniqWith([...base.properties, ...ext.properties], equalFn);
   }
 };
 function concatUnique(baseOrEq, ext) {
-  if (arguments.length === 1) {
-    return (base, ext2) => {
-      requireSameType(base, ext2);
-      requireStrategyExists(base, ext2, concatUniqueStrategy, "concatUnique");
-      return concatUniqueStrategy[base.path.type](base, ext2, baseOrEq);
+  if (typeof baseOrEq === "function") {
+    const eq = baseOrEq;
+    return (base2, innerExt) => {
+      requireSameType(base2, innerExt);
+      requireStrategyExists(
+        base2,
+        innerExt,
+        concatUniqueStrategy,
+        "concatUnique"
+      );
+      concatUniqueStrategy[base2.path.type]?.(base2, innerExt, eq);
     };
   }
-  if (arguments.length === 2) {
-    requireSameType(baseOrEq, ext);
-    requireStrategyExists(baseOrEq, ext, concatUniqueStrategy, "concatUnique");
-    return concatUniqueStrategy[baseOrEq.path.type](baseOrEq, ext);
+  const base = baseOrEq;
+  if (!ext) {
+    return;
   }
+  requireSameType(base, ext);
+  requireStrategyExists(base, ext, concatUniqueStrategy, "concatUnique");
+  concatUniqueStrategy[base.path.type]?.(base, ext);
 }
 export {
   concat,

package/dist/lib/packages.js

@@ -2,22 +2,26 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import execa from "execa";
+import { dedupe } from "@cedarjs/cli-helpers/packageManager";
+import { addRootPackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { getPackageManager } from "@cedarjs/project-config/packageManager";
 import { getPaths } from "./index.js";
 async function installModule(name, version = void 0) {
   if (isModuleInstalled(name)) {
     return false;
   }
   if (version === void 0) {
-    return installRedwoodModule(name);
+    return installCedarModule(name);
   } else {
-    await execa.command(`yarn add -D ${name}@${version}`, {
+    await addRootPackages([`${name}@${version}`], {
+      dev: true,
       stdio: "inherit",
       cwd: getPaths().base
     });
   }
   return true;
 }
-async function installRedwoodModule(module) {
+async function installCedarModule(module) {
   const packageJson = await import("@cedarjs/cli/package.json", { with: { type: "json" } });
   let version = packageJson.default.version;
   if (!isModuleInstalled(module)) {
@@ -35,21 +39,27 @@ async function installRedwoodModule(module) {
       }
     } catch (error) {
       throw new Error(
-        `Couldn't fetch packument for ${module}: ${error.message}`
+        `Couldn't fetch packument for ${module}: ${error instanceof Error ? error.message : String(error)}`
       );
     }
-    const versionIsPublished = Object.keys(packument.versions).includes(version);
+    const versionIsPublished = Object.keys(packument.versions ?? {}).includes(
+      version
+    );
     if (!versionIsPublished) {
       version = "canary";
     }
-    await execa.command(`yarn add -D ${module}@${version}`, {
-      stdio: "inherit",
-      cwd: getPaths().base
-    });
-    await execa.command(`yarn dedupe`, {
+    await addRootPackages([`${module}@${version}`], {
+      dev: true,
       stdio: "inherit",
       cwd: getPaths().base
     });
+    const dedupeCommand = dedupe();
+    if (dedupeCommand) {
+      await execa(getPackageManager(), [dedupeCommand], {
+        stdio: "inherit",
+        cwd: getPaths().base
+      });
+    }
     return true;
   }
   return false;
@@ -66,12 +76,12 @@ function isModuleInstalled(module) {
     return true;
   }
   const createdRequire = createRequire(import.meta.url);
-  return createdRequire.resolve.paths(`${module}/package.json`).some((requireResolvePath) => {
+  return createdRequire.resolve.paths(`${module}/package.json`)?.some((requireResolvePath) => {
     return fs.existsSync(path.join(requireResolvePath, module));
-  });
+  }) ?? false;
 }
 export {
+  installCedarModule,
   installModule,
-  installRedwoodModule,
   isModuleInstalled
 };

package/dist/lib/plugin.js

@@ -51,16 +51,23 @@ const PLUGIN_CACHE_BUILTIN = [
   "tc",
   "upgrade"
 ];
+function isErrorWithCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
 function loadCommandCache() {
-  let pluginCommandCache = PLUGIN_CACHE_DEFAULT;
+  let pluginCommandCache = { ...PLUGIN_CACHE_DEFAULT };
   const commandCachePath = path.join(
     getPaths().generated.base,
     PLUGIN_CACHE_FILENAME
   );
   try {
-    const localCommandCache = JSON.parse(fs.readFileSync(commandCachePath));
+    const localCommandCache = JSON.parse(
+      fs.readFileSync(commandCachePath, "utf8")
+    );
     let valid = true;
-    for (const [key, value] of Object.entries(localCommandCache)) {
+    for (const [key, value] of Object.entries(
+      localCommandCache
+    )) {
       if (key === "_builtin") {
         continue;
       }
@@ -73,7 +80,7 @@ function loadCommandCache() {
       };
     }
   } catch (error) {
-    if (error.code !== "ENOENT") {
+    if (!isErrorWithCode(error, "ENOENT")) {
       console.error(`Error loading plugin command cache at ${commandCachePath}`);
       console.error(error);
     }
@@ -162,7 +169,7 @@ async function installPluginPackage(packageName, packageVersion) {
       console.log(
         "The following error occurred while checking plugin compatibility for automatic installation:"
       );
-      const errorMessage = error.message ?? error;
+      const errorMessage = error instanceof Error ? error.message : String(error);
       console.log(errorMessage);
       if (errorMessage.includes("does not have a tag") || errorMessage.includes("does not have a version")) {
         process.exit(1);

package/dist/lib/pluralHelpers.js

@@ -33,7 +33,7 @@ To continue, the generator requires a unique plural form:`;
   const destroyMessage = `Cannot determine the plural of "${model}" originally used to generate the files. 
 To continue, the destroy command requires the plural form:`;
   const promptMessage = isDestroyer ? destroyMessage : generateMessage;
-  const initialPlural = model.slice(-1) === "s" ? `${model}es` : `${model}s`;
+  const initialPlural = model.endsWith("s") ? `${model}es` : `${model}s`;
   const promptResult = await prompts({
     type: "text",
     name: "plural",

package/dist/lib/project.js

@@ -5,7 +5,9 @@ const isTypeScriptProject = () => {
   const paths = getPaths();
   return fs.existsSync(path.join(paths.web.base, "tsconfig.json")) || fs.existsSync(path.join(paths.api.base, "tsconfig.json"));
 };
-function workspaces({ includePackages = false } = {}) {
+function workspaces({
+  includePackages = false
+} = {}) {
   const cedarPaths = getPaths();
   let workspaces2 = [];
   if (fs.existsSync(path.join(cedarPaths.web.base, "package.json"))) {

package/dist/lib/rollback.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "path";
-let rollback = [];
+const rollback = [];
 function addFunctionToRollback(func, atEnd = false) {
   const step = { type: "func", func };
   if (atEnd) {
@@ -9,11 +9,11 @@ function addFunctionToRollback(func, atEnd = false) {
     rollback.push(step);
   }
 }
-function addFileToRollback(path2, atEnd = false) {
+function addFileToRollback(filePath, atEnd = false) {
   const step = {
     type: "file",
-    path: path2,
-    content: fs.existsSync(path2) ? fs.readFileSync(path2) : null
+    path: filePath,
+    content: fs.existsSync(filePath) ? fs.readFileSync(filePath) : null
   };
   if (atEnd) {
     rollback.unshift(step);
@@ -21,7 +21,7 @@ function addFileToRollback(path2, atEnd = false) {
     rollback.push(step);
   }
 }
-async function executeRollback(_ = null, task = null) {
+const executeRollback = async (_, task) => {
   if (task) {
     task.title = "Reverting generator actions...";
   }
@@ -51,9 +51,9 @@ async function executeRollback(_ = null, task = null) {
     }
   }
   if (task) {
-    task.title = `Reverted because: ${task.task.message.error}`;
+    task.title = `Reverted because: ${task.task.message?.error ?? "unknown error"}`;
   }
-}
+};
 function resetRollback() {
   rollback.length = 0;
 }

package/dist/lib/schemaHelpers.js

@@ -9,13 +9,13 @@ const getExistingModelName = async (name) => {
     return void 0;
   }
   const modelName = name.replace(/[_-]/g, "").toLowerCase();
-  for (let model of Object.values(schemaMemo)) {
+  for (const model of Object.values(schemaMemo)) {
     if (model.name.toLowerCase() === modelName) {
       return model.name;
     }
   }
   const schema = (await getSchemaDefinitions()).datamodel;
-  for (let model of schema.models) {
+  for (const model of schema.models) {
     if (model.name.toLowerCase() === modelName) {
       return model.name;
     }
@@ -36,25 +36,24 @@ const getSchema = async (name) => {
   if (schemaMemo[modelName]) {
     return schemaMemo[modelName];
   }
-  const model = schema.models.find((model2) => model2.name === modelName);
+  const model = schema.models.find((m) => m.name === modelName);
   if (!model) {
     return void 0;
   }
-  model.fields.forEach((field) => {
+  const enrichedFields = model.fields.map((field) => {
     const fieldEnum = schema.enums.find((e) => field.type === e.name);
-    if (fieldEnum) {
-      field.enumValues = fieldEnum.values;
-    }
+    return fieldEnum ? { ...field, enumValues: fieldEnum.values } : { ...field };
   });
-  schemaMemo[modelName] = model;
-  return model;
+  const enrichedModel = { ...model, fields: enrichedFields };
+  schemaMemo[modelName] = enrichedModel;
+  return enrichedModel;
 };
 const getEnum = async (name) => {
   const schema = await getSchemaDefinitions();
   if (!name) {
-    return schema.metadata.datamodel.enums;
+    return [...schema.metadata.datamodel.enums];
   }
-  const model = schema.datamodel.enums.find((model2) => model2.name === name);
+  const model = schema.datamodel.enums.find((e) => e.name === name);
   if (!model) {
     throw new Error(
       `No enum schema definition found for \`${name}\` in schema.prisma file`
@@ -67,7 +66,8 @@ const getDataModel = async () => {
   return result.schemas;
 };
 const getSchemaDefinitions = async () => {
-  return getDMMF({ datamodel: await getDataModel() });
+  const document = await getDMMF({ datamodel: await getDataModel() });
+  return document;
 };
 const getSchemaConfig = async () => {
   return getConfig({

package/dist/lib/test.js

@@ -76,6 +76,10 @@ vi.mock("@cedarjs/project-config", async (importOriginal) => {
     }
   };
 });
+vi.mock("@cedarjs/project-config/packageManager", () => ({
+  getPackageManager: vi.fn(() => "yarn"),
+  resetPackageManagerCache: vi.fn()
+}));
 vi.mock("@cedarjs/cli-helpers", async (importOriginal) => {
   const originalCliHelpers = await importOriginal();
   return {

package/dist/lib/updateCheck.js

@@ -4,6 +4,8 @@ import ansis from "ansis";
 import boxen from "boxen";
 import latestVersion from "latest-version";
 import semver from "semver";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { getNodeRunnerArgs } from "@cedarjs/cli-helpers/packageManager/exec";
 import { getConfig } from "@cedarjs/project-config";
 import { spawnBackgroundProcess } from "./background.js";
 import { isLockSet, setLock, unsetLock } from "./locking.js";
@@ -88,7 +90,7 @@ function getUpdateMessage() {
   const data = readUpdateDataFile();
   const localTag = extractTagFromVersion(data.localVersion) || "latest";
   let updateCount = 0;
-  let message = " New updates to Cedar are available via `yarn cedar upgrade#REPLACEME#` ";
+  let message = ` New updates to Cedar are available via \`${formatCedarCommand(["upgrade#REPLACEME#"])}\` `;
   data.remoteVersions.forEach((version, tag) => {
     if (semver.gt(version, data.localVersion)) {
       updateCount += 1;
@@ -182,10 +184,10 @@ function updateCheckMiddleware(argv) {
   }
   if (shouldCheck()) {
     setLock(CHECK_LOCK_IDENTIFIER);
-    spawnBackgroundProcess("updateCheck", "yarn", [
-      "node",
+    const [bgCmd, bgCmdArgs] = getNodeRunnerArgs(
       path.join(import.meta.dirname, "updateCheckExecute.js")
-    ]);
+    );
+    spawnBackgroundProcess("updateCheck", bgCmd, bgCmdArgs);
   } else if (shouldShow()) {
     setLock(SHOW_LOCK_IDENTIFIER);
     process.on("exit", () => {

package/dist/middleware/checkNodeVersion.js

@@ -5,6 +5,11 @@ function checkNodeVersion() {
   const pVersion = process.version;
   const pVersionC = semver.clean(pVersion);
   const LOWER_BOUND = "v24.0.0";
+  if (!pVersionC) {
+    checks.ok = false;
+    checks.message = `Invalid Node.js version: ${pVersion}`;
+    return checks;
+  }
   if (semver.gte(pVersionC, LOWER_BOUND)) {
     return checks;
   }

package/dist/plugin.js

@@ -59,8 +59,6 @@ async function loadPlugins(yargs) {
         yargs.command({
           command: `${namespace} <command>`,
           describe: `Commands from ${namespace}`,
-          builder: () => {
-          },
           handler: () => {
           }
         });
@@ -97,6 +95,7 @@ async function loadPlugins(yargs) {
           describe: `Commands from ${namespaceInUse}`,
           builder: (yargs2) => {
             yargs2.command(commands).demandCommand();
+            return yargs2;
           },
           handler: () => {
           }
@@ -108,7 +107,7 @@ async function loadPlugins(yargs) {
   }
   const packagesToLoad = /* @__PURE__ */ new Set();
   for (const [packageName, cacheEntry] of Object.entries(pluginCommandCache)) {
-    if (packageName === "_builtin") {
+    if (packageName === "_builtin" || Array.isArray(cacheEntry)) {
       continue;
     }
     const commandFirstWords = [];
@@ -134,6 +133,9 @@ async function loadPlugins(yargs) {
   const commandsToRegister = [];
   if (foundMatchingPackage) {
     const packageToLoad = packagesToLoad.values().next().value;
+    if (!packageToLoad) {
+      throw new Error(`Invalid first value in ${packagesToLoad}`);
+    }
     const commands = await loadCommandsFromCacheOrPackage(
       packageToLoad,
       pluginCommandCache,
@@ -160,6 +162,7 @@ async function loadPlugins(yargs) {
       describe: `Commands from ${namespaceInUse}`,
       builder: (yargs2) => {
         yargs2.command(commandsToRegister).demandCommand();
+        return yargs2;
       },
       handler: () => {
       }
@@ -173,8 +176,6 @@ async function loadPlugins(yargs) {
       yargs.command({
         command: `${namespace} <command>`,
         describe: `Commands from ${namespace}`,
-        builder: () => {
-        },
         handler: () => {
         }
       });
@@ -185,24 +186,29 @@ async function loadPlugins(yargs) {
 }
 async function loadCommandsFromCacheOrPackage(packageName, cache, autoInstall, readFromCache) {
   let cacheEntry = void 0;
-  if (readFromCache) {
-    cacheEntry = cache !== void 0 ? cache[packageName] : void 0;
+  if (readFromCache && cache) {
+    const entry = cache[packageName];
+    if (entry && !Array.isArray(entry)) {
+      cacheEntry = entry;
+    }
   }
   if (cacheEntry !== void 0) {
     const commands = Object.entries(cacheEntry).map(([command, info]) => {
       return {
         command,
         describe: info.description,
-        aliases: info.aliases
+        aliases: info.aliases,
+        handler: () => {
+        }
       };
     });
     return commands;
   }
   const plugin = await loadPluginPackage(packageName, void 0, autoInstall);
   if (plugin) {
-    const commands = plugin.commands ?? [];
+    const rawCommands = plugin.commands ?? [];
     const cacheUpdate = {};
-    for (const command of commands) {
+    for (const command of rawCommands) {
       const info = {
         aliases: command.aliases,
         description: command.description
@@ -211,10 +217,10 @@ async function loadCommandsFromCacheOrPackage(packageName, cache, autoInstall, r
         cacheUpdate[command.command] = info;
       }
     }
-    if (Object.keys(cacheUpdate).length > 0) {
+    if (cache && Object.keys(cacheUpdate).length > 0) {
       cache[packageName] = cacheUpdate;
     }
-    return commands;
+    return plugin.commands ?? [];
   }
   return [];
 }

package/dist/telemetry/exporter.js

@@ -32,19 +32,26 @@ class CustomFileExporter {
    * @param spans the list of sampled Spans to be exported.
    */
   export(spans, resultCallback) {
-    for (let i = 0; i < spans.length; i++) {
-      const span = spans[i];
-      delete span["_spanProcessor"];
+    for (const span of spans) {
       fs.appendFileSync(
         this.#storageFilePath,
-        JSON.stringify(span, void 0, 2)
+        JSON.stringify(
+          span,
+          (key, value) => {
+            if (key === "_spanProcessor") {
+              return void 0;
+            }
+            return value;
+          },
+          2
+        )
       );
       fs.appendFileSync(this.#storageFilePath, ",");
     }
     resultCallback({ code: 0 });
   }
   /** Stops the exporter. */
-  shutdown() {
+  async shutdown() {
     if (!this.#isShutdown) {
       fs.truncateSync(
         this.#storageFilePath,

package/dist/telemetry/index.js

@@ -7,6 +7,7 @@ import {
   SamplingDecision
 } from "@opentelemetry/sdk-trace-node";
 import { hideBin } from "yargs/helpers";
+import { getNodeRunnerArgs } from "@cedarjs/cli-helpers/packageManager/exec";
 import { spawnBackgroundProcess } from "../lib/background.js";
 import { CustomFileExporter } from "./exporter.js";
 let traceProvider;
@@ -69,10 +70,10 @@ function shutdownTelemetry() {
       opentelemetry.trace.getActiveSpan()?.end();
     }
     traceExporter?.shutdown();
-    spawnBackgroundProcess("telemetry", "yarn", [
-      "node",
+    const [cmd, args] = getNodeRunnerArgs(
       path.join(import.meta.dirname, "send.js")
-    ]);
+    );
+    spawnBackgroundProcess("telemetry", cmd, args);
   } catch (error) {
     console.error("Telemetry error");
     console.error(error);