@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/lib/schemaHelpers.js

@@ -1,22 +1,21 @@
 import prismaInternals from "@prisma/internals";
-import { getSchemaPath } from "@cedarjs/project-config";
-import { singularize, isPlural } from "./cedarPluralize.js";
+import { getPrismaSchemas } from "@cedarjs/project-config";
+import { singularize, isPlural } from "@cedarjs/utils/cedarPluralize";
 import { ensureUniquePlural } from "./pluralHelpers.js";
-import { getPaths } from "./index.js";
-const { getConfig, getDMMF, getSchemaWithPath } = prismaInternals;
+const { getConfig, getDMMF } = prismaInternals;
 const schemaMemo = {};
 const getExistingModelName = async (name) => {
   if (!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;
     }
@@ -37,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`
@@ -64,13 +62,12 @@ const getEnum = async (name) => {
   return model;
 };
 const getDataModel = async () => {
-  const prismaConfigPath = getPaths().api.prismaConfig;
-  const schemaPath = await getSchemaPath(prismaConfigPath);
-  const result = await getSchemaWithPath(schemaPath);
+  const result = await getPrismaSchemas();
   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

@@ -26,6 +26,7 @@ vi.mock("@cedarjs/project-config", async (importOriginal) => {
           ),
           dataMigrations: path.join(BASE_PATH, "./api/dataMigrations"),
           src: path.join(BASE_PATH, "./api/src"),
+          lib: path.join(BASE_PATH, "./api/src/lib"),
           jobs: path.join(BASE_PATH, "./api/src/jobs"),
           services: path.join(BASE_PATH, "./api/src/services"),
           directives: path.join(BASE_PATH, "./api/src/directives"),
@@ -48,11 +49,11 @@ vi.mock("@cedarjs/project-config", async (importOriginal) => {
         packages: path.join(BASE_PATH, "packages"),
         generatorTemplates: path.join(BASE_PATH, "generatorTemplates"),
         generated: {
-          base: path.join(BASE_PATH, ".redwood"),
-          schema: path.join(BASE_PATH, ".redwood/schema.graphql"),
+          base: path.join(BASE_PATH, ".cedar"),
+          schema: path.join(BASE_PATH, ".cedar/schema.graphql"),
           types: {
-            includes: path.join(BASE_PATH, ".redwood/types/includes"),
-            mirror: path.join(BASE_PATH, ".redwood/types/mirror")
+            includes: path.join(BASE_PATH, ".cedar/types/includes"),
+            mirror: path.join(BASE_PATH, ".cedar/types/mirror")
           }
         }
       };
@@ -60,12 +61,26 @@ vi.mock("@cedarjs/project-config", async (importOriginal) => {
     getSchemaPath: () => {
       return path.join(globalThis.__dirname, "fixtures", "schema.prisma");
     },
+    getPrismaSchemas: async () => {
+      const schemaPath = path.join(
+        globalThis.__dirname,
+        "fixtures",
+        "schema.prisma"
+      );
+      return {
+        schemas: [[schemaPath, fs.readFileSync(schemaPath, "utf-8")]]
+      };
+    },
     getDataMigrationsPath: () => {
       return path.join(globalThis.__dirname, "fixtures", "migrations");
     }
   };
 });
-vi.mock("@cedarjs/cli-helpers", async (importOriginal) => {
+vi.mock("@cedarjs/project-config/packageManager", () => ({
+  getPackageManager: vi.fn(() => "yarn"),
+  resetPackageManagerCache: vi.fn()
+}));
+vi.mock("@cedarjs/cli-helpers/project", async (importOriginal) => {
   const originalCliHelpers = await importOriginal();
   return {
     ...originalCliHelpers,

package/dist/lib/updateCheck.js

@@ -3,7 +3,9 @@ import path from "path";
 import ansis from "ansis";
 import boxen from "boxen";
 import latestVersion from "latest-version";
-import semver from "semver";
+import { isGreater, isValid } from "verkit";
+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";
@@ -13,7 +15,7 @@ const SHOW_PERIOD = 24 * 60 * 6e4;
 const DEFAULT_DATETIME_MS = 9466848e5;
 const CHECK_LOCK_IDENTIFIER = "UPDATE_CHECK";
 const SHOW_LOCK_IDENTIFIER = "UPDATE_CHECK_SHOW";
-const EXCLUDED_COMMANDS = ["upgrade", "ts-to-js"];
+const EXCLUDED_COMMANDS = ["upgrade"];
 let persistenceDirectory;
 function getPersistenceDirectory() {
   if (persistenceDirectory) {
@@ -22,15 +24,35 @@ function getPersistenceDirectory() {
   persistenceDirectory = path.join(getPaths().generated.base, "updateCheck");
   return persistenceDirectory;
 }
-async function check() {
+function getLocalVersion() {
+  let version;
   try {
-    console.time("Update Check");
     const packageJson = JSON.parse(
       fs.readFileSync(path.join(getPaths().base, "package.json"), "utf-8")
     );
-    let localVersion = packageJson.devDependencies["@cedarjs/core"];
-    while (!/\d/.test(localVersion.charAt(0))) {
-      localVersion = localVersion.substring(1);
+    version = packageJson.devDependencies?.["@cedarjs/core"];
+  } catch {
+    return void 0;
+  }
+  if (typeof version === "string" && isValid(version)) {
+    return version;
+  }
+  return void 0;
+}
+async function check() {
+  try {
+    console.time("Update Check");
+    const localVersion = getLocalVersion();
+    if (!localVersion) {
+      console.log(
+        "Skipping update check: no pinned @cedarjs/core version found"
+      );
+      updateUpdateDataFile({
+        localVersion: "0.0.0",
+        remoteVersions: /* @__PURE__ */ new Map(),
+        checkedAt: (/* @__PURE__ */ new Date()).getTime()
+      });
+      return;
     }
     console.log(`Detected the current version of Cedar: '${localVersion}'`);
     const remoteVersions = /* @__PURE__ */ new Map();
@@ -67,16 +89,24 @@ function shouldCheck() {
     return false;
   }
   const data = readUpdateDataFile();
+  const localVersion = getLocalVersion();
+  if (localVersion && localVersion !== data.localVersion) {
+    return true;
+  }
   return data.checkedAt < (/* @__PURE__ */ new Date()).getTime() - CHECK_PERIOD;
 }
 function shouldShow() {
   if (isLockSet(SHOW_LOCK_IDENTIFIER)) {
     return false;
   }
+  const localVersion = getLocalVersion();
+  if (!localVersion) {
+    return false;
+  }
   const data = readUpdateDataFile();
   let newerVersion = false;
   data.remoteVersions.forEach((version) => {
-    newerVersion ||= semver.gt(version, data.localVersion);
+    newerVersion ||= isGreater(version, localVersion);
   });
   return data.shownAt < (/* @__PURE__ */ new Date()).getTime() - SHOW_PERIOD && newerVersion;
 }
@@ -88,9 +118,9 @@ 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)) {
+    if (isGreater(version, data.localVersion)) {
       updateCount += 1;
       if (tag === localTag) {
         message += `
@@ -180,20 +210,19 @@ function updateCheckMiddleware(argv) {
   if (EXCLUDED_COMMANDS.includes(argv._[0])) {
     return;
   }
-  if (shouldShow()) {
+  if (shouldCheck()) {
+    setLock(CHECK_LOCK_IDENTIFIER);
+    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", () => {
       showUpdateMessage();
       unsetLock(SHOW_LOCK_IDENTIFIER);
     });
   }
-  if (shouldCheck()) {
-    setLock(CHECK_LOCK_IDENTIFIER);
-    spawnBackgroundProcess("updateCheck", "yarn", [
-      "node",
-      path.join(import.meta.dirname, "updateCheckExecute.js")
-    ]);
-  }
 }
 export {
   CHECK_LOCK_IDENTIFIER,

package/dist/middleware/checkNodeVersion.js

@@ -1,11 +1,16 @@
-import semver from "semver";
-import c from "../lib/colors.js";
+import { clean, isGreaterOrEqual } from "verkit";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 function checkNodeVersion() {
   const checks = { ok: true };
   const pVersion = process.version;
-  const pVersionC = semver.clean(pVersion);
+  const pVersionC = clean(pVersion);
   const LOWER_BOUND = "v24.0.0";
-  if (semver.gte(pVersionC, LOWER_BOUND)) {
+  if (!pVersionC) {
+    checks.ok = false;
+    checks.message = `Invalid Node.js version: ${pVersion}`;
+    return checks;
+  }
+  if (isGreaterOrEqual(pVersionC, LOWER_BOUND)) {
     return checks;
   }
   checks.ok = false;

package/dist/middleware/{detectProjectRxVersion.js → detectProjectCedarVersion.js}

@@ -1,5 +1,5 @@
 import { getInstalledCedarVersion } from "../lib/index.js";
-async function detectRxVersion(argv) {
+async function detectCedarVersion(argv) {
   if (!argv.rwVersion) {
     return {
       rwVersion: await getInstalledCedarVersion()
@@ -8,5 +8,5 @@ async function detectRxVersion(argv) {
   return {};
 }
 export {
-  detectRxVersion as default
+  detectCedarVersion
 };

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);

package/dist/telemetry/resource.js

@@ -7,11 +7,10 @@ import system from "systeminformation";
 import { v4 as uuidv4, validate as validateUUID } from "uuid";
 import { getPaths, getRawConfig } from "@cedarjs/project-config";
 import { RWProject } from "@cedarjs/structure/dist/model/RWProject";
-import {
-  name as packageName,
-  version as packageVersion
-} from "../../package.js";
 async function getResources() {
+  const packageJson = await import("../../package.json", { with: { type: "json" } });
+  const packageName = packageJson.default["name"];
+  const packageVersion = packageJson.default["version"];
   let UID = uuidv4();
   try {
     const telemetryFile = path.join(getPaths().generated.base, "telemetry.txt");
@@ -29,7 +28,7 @@ async function getResources() {
         fs.writeFileSync(telemetryFile, UID);
       }
     }
-  } catch (_error) {
+  } catch {
   }
   const info = JSON.parse(
     await envinfo.run(
@@ -55,11 +54,11 @@ async function getResources() {
     developmentEnvironment = "gitpod";
   }
   const experiments = Object.keys(getRawConfig()["experimental"] || {});
-  const project = new RWProject({
-    projectRoot: getPaths().base
-  });
+  const project = new RWProject();
   const routes = project.getRouter().routes;
-  const prerenderedRoutes = routes.filter((route) => route.hasPrerender);
+  const prerenderedRoutes = routes.filter(
+    (route) => route.hasPrerender
+  );
   const complexity = [
     routes.length,
     prerenderedRoutes.length,
@@ -81,14 +80,12 @@ async function getResources() {
     "cpu.count": cpu.physicalCores,
     "memory.gb": Math.round(mem.total / 1073741824),
     "env.node_env": process.env.NODE_ENV || null,
-    "ci.redwood": !!process.env.REDWOOD_CI,
+    "ci.redwood": !!process.env.CEDAR_CI,
     "ci.isci": ci.isCI,
     "dev.environment": developmentEnvironment,
     complexity,
     sides,
     experiments: JSON.stringify(experiments),
-    webBundler: "vite",
-    // Hardcoded because this is now the only supported bundler
     uid: UID
   };
 }

package/dist/telemetry/send.js

@@ -1,15 +1,16 @@
 import fs from "node:fs";
 import path from "path";
+import { ExportResultCode } from "@opentelemetry/core";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { Resource } from "@opentelemetry/resources";
 import { getPaths } from "@cedarjs/project-config";
 import { getResources } from "./resource.js";
 async function main() {
   console.log(
-    "You can disable telemetry by:\n - setting the 'REDWOOD_DISABLE_TELEMETRY' environment variable\n - passing the '--no-telemetry' flag when using the CLI"
+    "You can disable telemetry by:\n - setting the 'CEDAR_DISABLE_TELEMETRY' environment variable\n - passing the '--no-telemetry' flag when using the CLI"
   );
   console.log(
-    "Information about Redwood telemetry can be found at:\n - https://telemetry.redwoodjs.com\n"
+    "Information about Cedar telemetry can be found at:\n - https://telemetry.redwoodjs.com\n"
   );
   const telemetryDir = path.join(getPaths().generated.base, "telemetry");
   fs.mkdirSync(telemetryDir, { recursive: true });
@@ -20,7 +21,7 @@ async function main() {
   const customResourceData = await getResources();
   console.timeEnd("Computed resource information");
   const resource = Resource.default().merge(new Resource(customResourceData));
-  const url = process.env.REDWOOD_REDIRECT_TELEMETRY || "https://quark.quantumparticle.io/v1/traces";
+  const url = process.env.CEDAR_REDIRECT_TELEMETRY || process.env.REDWOOD_REDIRECT_TELEMETRY || "https://quark.quantumparticle.io/v1/traces";
   const traceExporter = new OTLPTraceExporter({
     url
   });
@@ -53,14 +54,17 @@ async function main() {
       span.spanContext = () => span._spanContext;
       span.events = [];
     }
-    traceExporter.export(spans, ({ code, error }) => {
-      if (code !== 0) {
-        console.error("Encountered:");
-        console.error(error);
-        console.error("while exporting the following spans:");
-        console.error(spans);
+    traceExporter.export(
+      spans,
+      ({ code, error }) => {
+        if (code !== ExportResultCode.SUCCESS) {
+          console.error("Encountered:");
+          console.error(error);
+          console.error("while exporting the following spans:");
+          console.error(spans);
+        }
       }
-    });
+    );
     fs.writeFileSync(
       path.join(telemetryDir, `_${file}`),
       JSON.stringify(spans, null, 2)

package/dist/testLib/cells.js

@@ -117,9 +117,11 @@ const getCellGqlQuery = (ast) => {
   traverse(ast, {
     ExportNamedDeclaration({ node }) {
       if (node.exportKind === "value" && types.isVariableDeclaration(node.declaration)) {
-        const exportedQueryNode = node.declaration.declarations.find((d) => {
-          return types.isIdentifier(d.id) && d.id.name === "QUERY" && types.isTaggedTemplateExpression(d.init);
-        });
+        const exportedQueryNode = node.declaration.declarations.find(
+          (d) => {
+            return types.isIdentifier(d.id) && d.id.name === "QUERY" && types.isTaggedTemplateExpression(d.init);
+          }
+        );
         if (exportedQueryNode) {
           const templateExpression = exportedQueryNode.init;
           cellQuery = templateExpression.quasi.quasis[0].value.raw;