@cedarjs/cli 2.2.2-next.0 → 2.2.2-next.31

package/dist/commands/consoleHandler.js

@@ -9,7 +9,7 @@ const paths = getPaths();
 const loadPrismaClient = (replContext) => {
   const createdRequire = createRequire(import.meta.url);
   const { db } = createdRequire(path.join(paths.api.lib, "db"));
-  db[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = "PrismaClient";
+  db[Symbol.for("nodejs.util.inspect.custom")] = "PrismaClient";
   replContext.db = db;
 };
 const consoleHistoryFile = path.join(paths.generated.base, "console_history");

package/dist/commands/generate/package/filesTask.js

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { transformTSToJS } from "../../../lib/index.js";
+import { templateForFile } from "../yargsHandlerHelpers.js";
+const files = async ({
+  name,
+  folderName,
+  packageName,
+  fileName,
+  typescript,
+  tests: generateTests = true,
+  ...rest
+}) => {
+  const extension = typescript ? ".ts" : ".js";
+  const outputFiles = [];
+  const indexFile = await templateForFile({
+    name,
+    side: "packages",
+    generator: "package",
+    templatePath: "index.ts.template",
+    templateVars: rest,
+    outputPath: path.join(folderName, "src", `index${extension}`)
+  });
+  const readmeFile = await templateForFile({
+    name,
+    side: "packages",
+    generator: "package",
+    templatePath: "README.md.template",
+    templateVars: { packageName, ...rest },
+    outputPath: path.join(folderName, "README.md")
+  });
+  const packageJsonFile = await templateForFile({
+    name,
+    side: "packages",
+    generator: "package",
+    templatePath: "package.json.template",
+    templateVars: { packageName, ...rest },
+    outputPath: path.join(folderName, "package.json")
+  });
+  const tsconfigFile = await templateForFile({
+    name,
+    side: "packages",
+    generator: "package",
+    templatePath: "tsconfig.json.template",
+    templateVars: { packageName, ...rest },
+    outputPath: path.join(folderName, "tsconfig.json")
+  });
+  outputFiles.push(indexFile);
+  outputFiles.push(readmeFile);
+  outputFiles.push(packageJsonFile);
+  outputFiles.push(tsconfigFile);
+  if (generateTests) {
+    const testFile = await templateForFile({
+      name,
+      side: "packages",
+      generator: "package",
+      templatePath: "test.ts.template",
+      templateVars: rest,
+      outputPath: path.join(folderName, "src", `${fileName}.test${extension}`)
+    });
+    outputFiles.push(testFile);
+  }
+  return outputFiles.reduce(async (accP, [outputPath, content]) => {
+    const acc = await accP;
+    const template = typescript || outputPath.endsWith(".md") || outputPath.endsWith(".json") ? content : await transformTSToJS(outputPath, content);
+    return {
+      [outputPath]: template,
+      ...acc
+    };
+  }, Promise.resolve({}));
+};
+export {
+  files
+};

package/dist/commands/generate/package/package.js

@@ -0,0 +1,14 @@
+import { createHandler, createBuilder } from "../yargsCommandHelpers.js";
+const command = "package <name>";
+const description = "Generate a workspace Package";
+const builder = createBuilder({
+  componentName: "package",
+  addStories: false
+});
+const handler = createHandler("package");
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/generate/package/packageHandler.js

@@ -0,0 +1,158 @@
+import fs from "node:fs";
+import path from "node:path";
+import { paramCase, camelCase } from "change-case";
+import execa from "execa";
+import { Listr } from "listr2";
+import { terminalLink } from "termi-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getConfig } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import { getPaths, writeFilesTask } from "../../../lib/index.js";
+import { prepareForRollback } from "../../../lib/rollback.js";
+import { files } from "./filesTask.js";
+function nameVariants(nameArg) {
+  const base = path.basename(getPaths().base);
+  const [orgName, name] = nameArg.startsWith("@") ? nameArg.slice(1).split("/", 2) : [paramCase(base), nameArg];
+  const folderName = paramCase(name);
+  const packageName = "@" + paramCase(orgName) + "/" + folderName;
+  const fileName = camelCase(name);
+  return { name, folderName, packageName, fileName };
+}
+async function updateTsconfig(task) {
+  const tsconfigPath = path.join(getPaths().api.base, "tsconfig.json");
+  const tsconfig = await fs.promises.readFile(tsconfigPath, "utf8");
+  const tsconfigLines = tsconfig.split("\n");
+  const moduleLineIndex = tsconfigLines.findIndex(
+    (line) => /^\s*"module":\s*"/.test(line)
+  );
+  const moduleLine = tsconfigLines[moduleLineIndex];
+  if (moduleLine.toLowerCase().includes("node20") || // While Cedar doesn't officially endorse the usage of NodeNext, it
+  // will still work here, so I won't overwrite it
+  moduleLine.toLowerCase().includes("nodenext")) {
+    task.skip("tsconfig already up to date");
+    return;
+  }
+  tsconfigLines[moduleLineIndex] = moduleLine.replace(
+    /":\s*"[\w\d]+"/,
+    '": "Node20"'
+  );
+  await fs.promises.writeFile(tsconfigPath, tsconfigLines.join("\n"));
+}
+async function installAndBuild(folderName) {
+  const packagePath = path.join("packages", folderName);
+  await execa("yarn", ["install"], { stdio: "inherit", cwd: getPaths().base });
+  await execa("yarn", ["build"], { stdio: "inherit", cwd: packagePath });
+}
+const handler = async ({ name, force, ...rest }) => {
+  recordTelemetryAttributes({
+    command: "generate package",
+    force,
+    rollback: rest.rollback
+  });
+  if (name.replaceAll("/", "").length < name.length - 1) {
+    throw new Error(
+      `Invalid package name "${name}". Package names can have at most one slash.`
+    );
+  }
+  if (!getConfig().experimental.packagesWorkspace.enabled) {
+    const releaseNotes = terminalLink(
+      "release notes",
+      "https://github.com/cedarjs/cedar/releases"
+    );
+    console.error(
+      "This is an experimental feature. Please enable it in your redwood.toml file and then run this command again."
+    );
+    console.error();
+    console.error(`See the ${releaseNotes} for instructions on how to enable.`);
+    return;
+  }
+  let packageFiles = {};
+  const tasks = new Listr(
+    /** @type {import('listr2').ListrTask<ListrContext>[]} */
+    [
+      {
+        title: "Parsing package name...",
+        task: (ctx) => {
+          ctx.nameVariants = nameVariants(name);
+        }
+      },
+      {
+        title: "Updating workspace config...",
+        task: async (ctx, task) => {
+          const rootPackageJsonPath = path.join(getPaths().base, "package.json");
+          const packageJson = JSON.parse(
+            await fs.promises.readFile(rootPackageJsonPath, "utf8")
+          );
+          if (!Array.isArray(packageJson.workspaces)) {
+            throw new Error(
+              "Invalid workspace config in " + rootPackageJsonPath
+            );
+          }
+          const packagePath = `packages/${ctx.nameVariants.folderName}`;
+          const hasWildcardPackagesWorkspace = packageJson.workspaces.includes("packages/*");
+          const hasNamedPackagesWorkspace = packageJson.workspaces.includes(packagePath);
+          const hasOtherNamedPackages = packageJson.workspaces.some(
+            (workspace) => workspace.startsWith("packages/") && workspace !== packagePath
+          );
+          if (hasWildcardPackagesWorkspace || hasNamedPackagesWorkspace) {
+            task.skip("Workspaces already configured");
+          } else {
+            if (hasOtherNamedPackages) {
+              packageJson.workspaces.push(packagePath);
+            } else {
+              packageJson.workspaces.push("packages/*");
+            }
+            await fs.promises.writeFile(
+              rootPackageJsonPath,
+              JSON.stringify(packageJson, null, 2)
+            );
+          }
+        }
+      },
+      {
+        title: "Updating api side tsconfig file...",
+        task: (_ctx, task) => updateTsconfig(task)
+      },
+      {
+        title: "Generating package files...",
+        task: async (ctx) => {
+          packageFiles = await files({ ...ctx.nameVariants, ...rest });
+          return writeFilesTask(packageFiles, { overwriteExisting: force });
+        }
+      },
+      {
+        title: "Installing and building...",
+        task: (ctx) => installAndBuild(ctx.nameVariants.folderName)
+      },
+      {
+        title: "Cleaning up...",
+        task: () => {
+          execa.sync("yarn", [
+            "eslint",
+            "--fix",
+            "--config",
+            `${getPaths().base}/node_modules/@cedarjs/eslint-config/index.js`,
+            ...Object.keys(packageFiles)
+          ]);
+        }
+      }
+    ],
+    { rendererOptions: { collapseSubtasks: false }, exitOnError: true }
+  );
+  try {
+    if (rest.rollback && !force) {
+      prepareForRollback(tasks);
+    }
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  handler,
+  nameVariants,
+  updateTsconfig
+};

package/dist/commands/generate/package/templates/README.md.template

@@ -0,0 +1,15 @@
+# Shared Package '${packageName}'
+
+Use code in this package by adding it to the dependencies on the side you want
+to use it, with the special `workspace:*` version. After that you can import it
+into your code:
+
+```json
+  "dependencies": {
+    "${packageName}": "workspace:*"
+  }
+```
+
+```javascript
+import { ${camelName} } from '${packageName}';
+```

package/dist/commands/generate/package/templates/index.ts.template

@@ -0,0 +1,3 @@
+export function ${camelName}() {
+  return 0
+}

package/dist/commands/generate/package/templates/package.json.template

@@ -0,0 +1,15 @@
+{
+  "name": "${packageName}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch"
+  },
+  "devDependencies": {
+    "@cedarjs/testing": "2.2.1",
+    "typescript": "5.9.3"
+  }
+}

package/dist/commands/generate/package/templates/scenarios.ts.template

@@ -0,0 +1,8 @@
+import type { ScenarioData } from '@cedarjs/testing/api'
+
+export const standard = defineScenario({
+  // Define the "fixture" to write into your test database here
+  // See guide: https://cedarjs.com/docs/testing#scenarios
+})
+
+export type StandardScenario = ScenarioData<unknown>

package/dist/commands/generate/package/templates/test.ts.template

@@ -0,0 +1,7 @@
+import { ${camelName} } from './index.js'
+
+describe('${camelName}', () => {
+  it('should not throw any errors', async () => {
+    expect(${camelName}()).not.toThrow()
+  })
+})

package/dist/commands/generate/package/templates/tsconfig.json.template

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "ES2023",
+    "module": "Node20",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+  },
+  "include": ["src"],
+}

package/dist/commands/generate/script/scriptHandler.js

@@ -1,5 +1,5 @@
-import path from "path";
-import fs from "fs-extra";
+import fs from "node:fs";
+import path from "node:path";
 import { Listr } from "listr2";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 import { errorTelemetry } from "@cedarjs/telemetry";
@@ -11,26 +11,27 @@ import {
 } from "../../../lib/index.js";
 import { prepareForRollback } from "../../../lib/rollback.js";
 import { validateName } from "../helpers.js";
-const TEMPLATE_PATH = path.resolve(
-  import.meta.dirname,
-  "templates",
-  "script.ts.template"
-);
-const TSCONFIG_TEMPLATE = path.resolve(
-  import.meta.dirname,
-  "templates",
-  "tsconfig.json.template"
-);
+import { customOrDefaultTemplatePath } from "../yargsHandlerHelpers.js";
 const files = async ({ name, typescript = false }) => {
   const outputFilename = `${name}.${typescript ? "ts" : "js"}`;
   const outputPath = path.join(getPaths().scripts, outputFilename);
   const scriptTsConfigPath = path.join(getPaths().scripts, "tsconfig.json");
-  const template = fs.readFileSync(TEMPLATE_PATH, "utf-8");
+  const templatePath = customOrDefaultTemplatePath({
+    side: "scripts",
+    generator: "script",
+    templatePath: "script.ts.template"
+  });
+  const template = fs.readFileSync(templatePath, "utf-8");
+  const tsconfigTemplatePath = customOrDefaultTemplatePath({
+    side: "scripts",
+    generator: "script",
+    templatePath: "tsconfig.json.template"
+  });
   return {
     [outputPath]: typescript ? template : await transformTSToJS(outputPath, template),
     // Add tsconfig for type and cmd+click support if project is TS
     ...typescript && !fs.existsSync(scriptTsConfigPath) && {
-      [scriptTsConfigPath]: fs.readFileSync(TSCONFIG_TEMPLATE, "utf-8")
+      [scriptTsConfigPath]: fs.readFileSync(tsconfigTemplatePath, "utf-8")
     }
   };
 };

package/dist/commands/generate/yargsHandlerHelpers.js

@@ -26,12 +26,19 @@ const customOrDefaultTemplatePath = ({
     templatePath
   );
   const customPath = path.join(
-    getPaths()[side].generators,
+    getPaths().generatorTemplates,
+    side,
     generator,
     templatePath
   );
+  const deprecatedCustomPath = getPaths()[side].generators ? path.join(getPaths()[side].generators, generator, templatePath) : void 0;
   if (fs.existsSync(customPath)) {
     return customPath;
+  } else if (deprecatedCustomPath && fs.existsSync(deprecatedCustomPath)) {
+    console.log(
+      `Having generator templates in ${getPaths()[side].generators} has been deprecated. Please move them to ${getPaths().generatorTemplates}.`
+    );
+    return deprecatedCustomPath;
   } else {
     return defaultPath;
   }
@@ -45,20 +52,21 @@ const templateForFile = async ({
   templatePath,
   templateVars
 }) => {
-  const basePath = getPaths()[side][sidePathSection];
+  const basePath = sidePathSection ? getPaths()[side][sidePathSection] : getPaths()[side];
   const fullOutputPath = path.join(basePath, outputPath);
   const fullTemplatePath = customOrDefaultTemplatePath({
     generator,
     templatePath,
     side
   });
-  const content = await generateTemplate(fullTemplatePath, {
+  const mergedTemplateVars = {
     name,
     outputPath: ensurePosixPath(
       `./${path.relative(getPaths().base, fullOutputPath)}`
     ),
     ...templateVars
-  });
+  };
+  const content = await generateTemplate(fullTemplatePath, mergedTemplateVars);
   return [fullOutputPath, content];
 };
 const templateForComponentFile = async ({

package/dist/commands/generate.js

@@ -11,6 +11,7 @@ import * as generateJob from "./generate/job/job.js";
 import * as generateLayout from "./generate/layout/layout.js";
 import * as generateModel from "./generate/model/model.js";
 import * as generateOgImage from "./generate/ogImage/ogImage.js";
+import * as generatePackage from "./generate/package/package.js";
 import * as generatePage from "./generate/page/page.js";
 import * as generateRealtime from "./generate/realtime/realtime.js";
 import * as generateScaffold from "./generate/scaffold/scaffold.js";
@@ -28,7 +29,7 @@ const builder = (yargs) => yargs.command("types", "Generate supplementary code",
   } catch (error) {
     process.exitCode = error.exitCode ?? 1;
   }
-}).command(generateCell).command(generateComponent).command(generateDataMigration).command(generateDbAuth).command(generateDirective).command(generateFunction).command(generateJob).command(generateLayout).command(generateModel).command(generateOgImage).command(generatePage).command(generateRealtime).command(generateScaffold).command(generateScript).command(generateSdl).command(generateSecret).command(generateService).demandCommand().epilogue(
+}).command(generateCell).command(generateComponent).command(generateDataMigration).command(generateDbAuth).command(generateDirective).command(generateFunction).command(generateJob).command(generateLayout).command(generateModel).command(generateOgImage).command(generatePackage).command(generatePage).command(generateRealtime).command(generateScaffold).command(generateScript).command(generateSdl).command(generateSecret).command(generateService).demandCommand().epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#generate-alias-g"

package/dist/commands/setup/generator/generator.js

@@ -4,13 +4,7 @@ import { terminalLink } from "termi-link";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 const command = "generator <name>";
 const description = "Copies generator templates locally for customization";
-const EXCLUDE_GENERATORS = [
-  "dataMigration",
-  "dbAuth",
-  "generator",
-  "script",
-  "secret"
-];
+const EXCLUDE_GENERATORS = ["dataMigration", "dbAuth", "generator", "secret"];
 const builder = (yargs) => {
   const availableGenerators = fs.readdirSync(path.join(import.meta.dirname, "../../generate"), {
     withFileTypes: true

package/dist/commands/setup/generator/generatorHandler.js

@@ -5,17 +5,22 @@ import c from "../../../lib/colors.js";
 import { getPaths } from "../../../lib/index.js";
 const SIDE_MAP = {
   web: ["cell", "component", "layout", "page", "scaffold"],
-  api: ["function", "sdl", "service"]
+  api: ["function", "sdl", "service"],
+  scripts: ["script"],
+  packages: ["package"]
 };
 const copyGenerator = (name, { force }) => {
-  const side = SIDE_MAP["web"].includes(name) ? "web" : "api";
+  const side = Object.keys(SIDE_MAP).find((key) => SIDE_MAP[key].includes(name));
+  if (!side) {
+    throw new Error(`Invalid generator name: ${name}`);
+  }
   const from = path.join(
     import.meta.dirname,
     "../../generate",
     name,
     "templates"
   );
-  const to = path.join(getPaths()[side].generators, name);
+  const to = path.join(getPaths().generatorTemplates, side, name);
   fs.cpSync(from, to, { recursive: true, force });
   return to;
 };