@cedarjs/codemods 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,297 @@
+# Codemods
+
+- [Codemods](#codemods)
+  - [Purpose and Vision](#purpose-and-vision)
+  - [Package Leads](#package-leads)
+  - [Contributing](#contributing)
+
+## Purpose and Vision
+
+This package contains codemods that automate upgrading a Redwood project.
+
+## Package Leads
+
+- Daniel Choudhury (@dac09)
+- Dominic Saadi (@jtoar)
+
+## Usage
+
+Listing available codemods:
+
+```shell
+npx @redwoodjs/codemods list v0.38.x
+```
+
+Applying a single one:
+
+```shell
+npx @redwoodjs/codemods add-directives
+```
+
+---
+
+## Contributing
+
+> **Note** that this is a CLI—that is, it's meant to be executed with `npx`. This means the normal contribution flow (using `rwfw`) doesn't apply.
+
+You should be familiar with [jscodeshift](https://github.com/facebook/jscodeshift).
+Its API isn't documented too well so we'll try to explain some of it here.
+
+Like Babel and ESLint, jscodeshift is all about ASTs.
+The difference is that it's overwriting files.
+That means things that Babel doesn't care about, like spaces, styling (single quotes or double quotes, etc.), all of a sudden matter a lot.
+The parser jscodeshift uses, [recast](https://github.com/benjamn/recast), knows how to preserve these details as much as possible.
+
+### Generating a new Codemod
+
+```shell
+cd packages/codemods
+yarn generate:codemod
+```
+
+Follow the interactive guide to specify the Redwood framework version for the codemod and type of codemod.
+
+### Structure of this package
+
+The root of the CLI is run from `src/codemods.ts`, which loads all the available codemods from the `src/codemods/*` folder.
+
+Codemods are organised by version. For example, for upgrading from v0.37.x -> v0.38.x, the codemods are in the `src/codemods/v0.38.x` folder.
+
+Each codemod has the following files:
+
+- README.md—to explain what this codemod does
+- {codemodName}.ts—this is the actual implementation of the codemod. You can export whatever you like here, and use it in the yargs handler
+- {codemodName}.yargs.ts—this is the yargs (CLI) handler that actually invokes your codemod. Each of the yargs handlers should export: `command`, `description` and `handler` at least. More info on how this is handled with yargs `commandDir` here: [Yargs advanced docs](https://github.com/yargs/yargs/blob/main/docs/advanced.md#commanddirdirectory-opts)
+- {codemodName}.test.ts—all jscodeshift codemods should implement a test. They're fairly simple to write. Have a look at the testing section for more details
+
+### Different types of codemods
+
+Codemods are sometimes really simple, e.g. just normal string replace or updating a package.json. But other times we use jscodeshift to change code on a redwood project
+
+Here are a few different examples to help you get familiarised:
+
+- [Rename config in Redwood.toml](packages/codemods/src/codemods/v0.38.x/renameApiProxyPath)—
+  Simple string replace on the user's `redwood.toml`. No ASTs, no complications!
+
+- [Add Directives](packages/codemods/src/codemods/v0.37.x/addDirectives)—
+  Download files from the RedwoodJS template because we've added new files that are needed in a user's project. No ASTs involved
+
+- [Update GraphQL Function](packages/codemods/src/codemods/v0.37.x/updateGraphQLFunction)—
+  A more complex example, which uses `jscodeshift` and ASTs to update code in a user's project
+
+The rest of the docs will focus on the more complex cases (the third example).
+
+### A Typical Transform
+
+A typical transform looks something like this:
+
+```typescript
+// fooToBar.ts
+
+import type { FileInfo, API } from 'jscodeshift'
+
+export default function transform(file: FileInfo, api: API) {
+  const j = api.jscodeshift
+
+  const root = j(file.source)
+
+  return root.findVariableDeclarators('foo').renameTo('bar').toSource()
+}
+```
+
+You can then run this transform on files via the CLI:
+
+```
+yarn run jscodeshift -t fooToBar.ts foo.js
+```
+
+In this way, jscodeshift is similar to Jest in that it's a runner.
+
+> 💡 **Tip**
+>
+> An extremely useful tool to write the actual transform is [ASTExplorer](https://astexplorer.net/).
+> This lets you see how your codemods change input source, in real time!
+
+#### The API
+
+In the example above, `file` is the file it's running the transformation on
+and `jscodeshift` itself is actually a property of `api`.
+Since it's used so much, you'll see this pattern a lot:
+
+```javascript
+const j = api.jscodeshift
+```
+
+`j` exposes the whole api, but it's also a function—it parses its argument into a `Collection`, jscodeshift's major type. It's similar to a javascript array and has many of the same methods (`forEach`, `map`, etc.).
+The best way to familiarize yourself with its methods is to either 1) look at a bunch of examples or 2) [skim the source](https://github.com/facebook/jscodeshift/blob/main/src/Collection.js).
+
+### Writing a transform
+
+When beginning to write a transform, your best bet is to start by pasting the code you want to transform into [AST Explorer](https://astexplorer.net/). Use it to figure out what node you want, and then use one of `jscodeshift`'s `find` methods to find it:
+
+````typescript
+import type { FileInfo, API } from 'jscodeshift'
+
+export default function transform(file: FileInfo, api: API) {
+  const j = api.jscodeshift
+
+  const root = j(file.source)
+
+  /**
+   * This finds the line:
+   *
+   * ```
+   * import { ... } from '@cedarjs/router'
+   * ```
+   */
+  return root.find(j.ImportDeclaration, {
+    source: {
+      type: 'Literal',
+      value: '@redwoodjs/router',
+    },
+  })
+}
+````
+
+Sometimes `jscodeshift` has a more-specific find method than `find`, like `findVariableDeclarators`. Use it when you can—it makes things a lot easier.
+But note that these find methods aren't on `Collection`.
+They're in the extensions:
+
+- [Node](https://github.com/facebook/jscodeshift/blob/main/src/collections/Node.js)
+- [JSXElement](https://github.com/facebook/jscodeshift/blob/main/src/collections/JSXElement.js)
+- etc.
+
+After you find what you're looking for, you usually want to replace it with something else.
+Again, use AST Explorer to find out what the AST of that something else is.
+Then, instead of using a type (like `j.ImportDeclaration`) to find it, use a builder (like `j.importDeclaration`—it's just the type camelcased) to make it.
+
+Again, sometimes jscodeshift has a method that makes this trivial, especially for simple operations, like renaming or removing something (just use `renameTo` or `remove`).
+But sometimes you'll just have to use one of the more generic methods: `replaceWith`, `insertBefore`, `insertAfter`, etc.
+
+## Testing
+
+Although jscodeshift has a built-in way of doing testing, we have a slightly different way of testing.
+
+There are 3 key test utils you need to be aware of (located in [packages/codemods/testUtils/index.ts](https://github.com/redwoodjs/redwood/blob/main/packages/codemods/testUtils/index.ts)).
+
+1. `matchTransformSnapshot`—this lets you give it a transformName (i.e. the transform you're writing), and a fixtureName. The fixtures should be located in `__testfixtures__`, and have `{fixtureName}.input.{js,ts}` and `{fixtureName}.output.{js,ts}` files.
+
+Note that the fixtureName can be anything you want, and you can have multiple fixtures.
+
+```js
+describe('Update API Imports', () => {
+  it('Updates @redwoodjs/api imports', async () => {
+    await matchTransformSnapshot('updateApiImports', 'apiImports')
+  })
+})
+```
+
+2. `matchInlineTransformSnapshot`—very similar to above, but use this in case you want to just provide your fixtures inline
+
+```js
+it('Modifies imports (inline)', async () => {
+  await matchInlineTransformSnapshot(
+    'updateGraphQLFunction', // <--- transform name, so we know which transform to apply
+    `import {
+        createGraphQLHandler,   // <-- input source
+        makeMergedSchema,
+      } from '@cedarjs/api'`,
+    `import { createGraphQLHandler } from '@cedarjs/graphql-server'`, // <-- expected output
+  )
+})
+```
+
+3. `matchFolderTransform` - use this, when you're modifying contents of multiple files, and adding/deleting files from the user's project during the codemod.
+
+```js
+test('Removes babel config for default setup', async () => {
+  import transform from '../updateBabelConfig'
+
+  // pass in your transform here 👇
+  await matchFolderTransform(transform, 'my-default-fixture')
+  // and tell it which folder to use as fixture here ☝️
+})
+```
+
+In the above example, it will run the transform from `updateBabelConfig` against a fixture located in the `__testfixtures__/my-default-fixture/input` folder and compare with the `__testfixtures__/my-default-fixture/output` folder.
+
+The `matchFolderTransform` helper will check
+a) If the files in the output fixture folder are present after transform
+b) If their contents match
+
+## How to run your changes on a test redwood project
+
+1. Clean all your other packages, and rebuild once:
+
+```shell
+# root of framework
+yarn build:clean
+yarn build
+```
+
+2. Build the codemods package
+
+```shell
+cd packages/codemods
+yarn build
+```
+
+3. Running the updated CLI
+
+The CLI is meant to be run on a redwood project (i.e. it expects you to be cd'd into a redwood project), but you can provide it as an environment variable too!
+
+```shell
+RWJS_CWD=/path/to/rw-project node "./packages/codemods/dist/codemods.js" {your-codemod-name}
+# ☝️ this is the path to your rw project (not the framework!)
+```
+
+> **💡 Tip**
+>
+> If you're making changes, and want to watch your source and build on changes, you can use the [watch cli](https://www.npmjs.com/package/watch-cli)
+>
+> ```shell
+> # Assuming in packages/codemods/
+> watch -p "./src/**/*" -c "yarn build"
+> ```
+
+4. Debugging
+
+If you have a node and want to see/confirm what you're working with you can
+pass it to jscodeshift and then call `.toSource()` on it.
+
+**Example**
+
+```js
+const j = api.jscodeshift
+const root = j(file.source)
+
+const graphQLClientConfig = j.jsxAttribute(
+  j.jsxIdentifier('graphQLClientConfig'),
+  j.jsxExpressionContainer(j.objectExpression([])),
+)
+
+console.log('graphQLClientConfig prop', j(graphQLClientConfig).toSource())
+// Will log:
+// graphQLClientConfig={{}}
+```
+
+If you have a collection of nodes you first need to get just one of the
+collection items, and then get the node out of that.
+
+**Example**
+
+```js
+const j = api.jscodeshift
+const root = j(file.source)
+
+const redwoodApolloProvider = root.findJSXElements('RedwoodApolloProvider')
+
+console.log(
+  '<RedwoodApolloProvider>',
+  j(redwoodApolloProvider.get(0).node).toSource(),
+)
+// Will log:
+// <RedwoodApolloProvider useAuth={useAuth}>
+//   <Routes />
+// </RedwoodApolloProvider>
+```

package/dist/codemods/list.yargs.js

@@ -0,0 +1,67 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var list_yargs_exports = {};
+__export(list_yargs_exports, {
+  aliases: () => aliases,
+  builder: () => builder,
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(list_yargs_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_yargs_parser = require("yargs-parser");
+const command = "list <rwVersion>";
+const description = "List available codemods for a specific version";
+const aliases = ["ls"];
+const builder = (yargs) => {
+  yargs.positional("rwVersion", {
+    type: "string",
+    required: true,
+    choices: import_fs.default.readdirSync(__dirname).filter((file) => !import_fs.default.statSync(import_path.default.join(__dirname, file)).isFile())
+    // Only list the folders
+  });
+};
+const handler = ({ rwVersion }) => {
+  console.log("Listing codemods for", rwVersion);
+  console.log();
+  const modsForVersion = import_fs.default.readdirSync(import_path.default.join(__dirname, rwVersion));
+  modsForVersion.forEach((codemod) => {
+    console.log(`- npx @cedarjs/codemods ${(0, import_yargs_parser.decamelize)(codemod)}`);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aliases,
+  builder,
+  command,
+  description,
+  handler
+});

package/dist/codemods/v2.3.x/tsconfigForRouteHooks/tsconfigForRouteHooks.js

@@ -0,0 +1,74 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tsconfigForRouteHooks_exports = {};
+__export(tsconfigForRouteHooks_exports, {
+  default: () => addApiAliasToTsConfig
+});
+module.exports = __toCommonJS(tsconfigForRouteHooks_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_prettify = __toESM(require("../../../lib/prettify"));
+async function addApiAliasToTsConfig() {
+  const ts = await import("typescript");
+  const webConfigPath = ts.findConfigFile(
+    (0, import_project_config.getPaths)().web.base,
+    ts.sys.fileExists
+  );
+  if (!webConfigPath) {
+    throw new Error(
+      "Could not find tsconfig.json in your web side. Please follow release notes to update your config manually."
+    );
+  }
+  const { config: webConfig } = ts.parseConfigFileTextToJson(
+    webConfigPath,
+    ts.sys.readFile(webConfigPath)
+    // If file exists, it has contents
+  );
+  if (webConfig?.compilerOptions) {
+    const newPathAliases = {
+      ...webConfig.compilerOptions.paths,
+      "$api/*": ["../api/*"]
+    };
+    const updatedConfig = {
+      ...webConfig,
+      compilerOptions: {
+        ...webConfig.compilerOptions,
+        paths: newPathAliases
+      }
+    };
+    ts.sys.writeFile(
+      webConfigPath,
+      // @NOTE: prettier will remove trailing commas, but whatever
+      await (0, import_prettify.default)(JSON.stringify(updatedConfig), { parser: "json" })
+    );
+  } else {
+    throw new Error(
+      "Could not read your web/tsconfig.json. Please follow release notes to update your config manually."
+    );
+  }
+}

package/dist/codemods/v2.3.x/tsconfigForRouteHooks/tsconfigForRouteHooks.yargs.js

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tsconfigForRouteHooks_yargs_exports = {};
+__export(tsconfigForRouteHooks_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(tsconfigForRouteHooks_yargs_exports);
+var import_tasuku = __toESM(require("tasuku"));
+var import_tsconfigForRouteHooks = __toESM(require("./tsconfigForRouteHooks"));
+const command = "tsconfig-for-route-hooks";
+const description = "(v2.3.x->v2.3.x) Allow $api imports in *.routesHooks.ts files";
+const handler = () => {
+  (0, import_tasuku.default)("Tsconfig For Route Hooks", async ({ setOutput }) => {
+    (0, import_tsconfigForRouteHooks.default)();
+    setOutput("All done! Run `yarn rw lint --fix` to prettify your code");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v2.x.x/configureFastify/configureFastify.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var configureFastify_exports = {};
+__export(configureFastify_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(configureFastify_exports);
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  ast.find(j.AssignmentExpression).forEach((path) => {
+    const lhs = path.value.left;
+    const rhs = path.value.right;
+    if (lhs && rhs.type === "Identifier" && rhs.name === "config") {
+      j(path).replaceWith(
+        j.expressionStatement(
+          j.assignmentExpression(
+            "=",
+            j.identifier("module.exports"),
+            j.identifier("{ config }")
+          )
+        )
+      );
+    }
+  });
+  return ast.toSource();
+}

package/dist/codemods/v2.x.x/configureFastify/configureFastify.yargs.js

@@ -0,0 +1,83 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var configureFastify_yargs_exports = {};
+__export(configureFastify_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(configureFastify_yargs_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_fetch = require("@whatwg-node/fetch");
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_prettify = __toESM(require("../../../lib/prettify"));
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "configure-fastify";
+const description = "(v2.x.x->v2.x.x) Updates api side\u2019s server.config.js to configure Fastify";
+const handler = () => {
+  (0, import_tasuku.default)("Configure Fastify", async ({ setOutput }) => {
+    const [API_SERVER_CONFIG_PATH] = import_fast_glob.default.sync("server.config.{js,ts}", {
+      cwd: (0, import_project_config.getPaths)().api.base,
+      absolute: true
+    });
+    if (import_fs.default.existsSync(API_SERVER_CONFIG_PATH)) {
+      await (0, import_runTransform.default)({
+        transformPath: import_path.default.join(__dirname, "configureFastify.js"),
+        targetPaths: [API_SERVER_CONFIG_PATH]
+      });
+      import_fs.default.writeFileSync(
+        API_SERVER_CONFIG_PATH,
+        await (0, import_prettify.default)(import_fs.default.readFileSync(API_SERVER_CONFIG_PATH, "utf-8"))
+      );
+      setOutput("All done!");
+    } else {
+      const res = await (0, import_fetch.fetch)(
+        "https://raw.githubusercontent.com/cedarjs/cedar/main/packages/create-cedar-app/template/api/server.config.js"
+      );
+      const text = await res.text();
+      const NEW_API_SERVER_CONFIG_PATH = import_path.default.join(
+        (0, import_project_config.getPaths)().api.base,
+        "server.config.js"
+      );
+      import_fs.default.writeFileSync(NEW_API_SERVER_CONFIG_PATH, await (0, import_prettify.default)(text));
+      setOutput(
+        "Done! No server.config.js found, so we updated your project to use the latest version."
+      );
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});