create-nexwire 4.2.1 → 4.2.3

package/express/src/framework/kernel.ts

@@ -1,52 +1,54 @@
-import { appConfig } from "@/config/index.js";
-import { validateConfig } from "@/config/validate.js";
-import { initDatabase } from "@/framework/database/connection.js";
-import { createHttpApp } from "@/framework/http/app.js";
-import { notFound, onError } from "@/framework/http/logger.js";
-import { ensurePublicDir, hasUiBuild, uiIndexMiddleware, uiStaticMiddleware } from "@/framework/http/static.js";
-import { registerModuleRoutes } from "@/framework/modules/routes.js";
-import { bootQueueJobs } from "@/framework/queue/queue.js";
-import { setupQueueDashboard } from "@/framework/queue/ui.js";
-import { initRedis } from "@/framework/redis/client.js";
-import { storage } from "@/framework/storage/storage.js";
-
-/**
- * Why: Assembles app kernel and boots all framework dependencies.
- * When: HTTP server startup.
- * Where: Called by server runtime entrypoint.
- * How: Initializes storage/db/redis/queues/events/routes and optional UI.
- */
-export async function createKernel() {
-  validateConfig();
-
-  await storage.init();
-
-  await initRedis();
-
-  const app = createHttpApp();
-
-  await initDatabase();
-  await bootQueueJobs();
-  await registerModuleRoutes(app);
-
-  const queueDashboard = await setupQueueDashboard();
-  if (typeof queueDashboard.route === "function") {
-    queueDashboard.route(app);
-  } else {
-    app.use(queueDashboard.basePath, queueDashboard.route);
-  }
-
-  if (appConfig.uiEnabled) {
-    ensurePublicDir();
-  }
-
-  if (appConfig.uiEnabled && hasUiBuild()) {
-    app.use(uiStaticMiddleware);
-    app.get("*", uiIndexMiddleware);
-  }
-
-  app.use(notFound);
-  app.use(onError);
-
-  return { app, bullBoard: queueDashboard };
-}
+import { appConfig } from "@/config/index.js";
+import { validateConfig } from "@/config/validate.js";
+import { initDatabase } from "@/framework/database/connection.js";
+import { createHttpApp } from "@/framework/http/app.js";
+import { notFound, onError } from "@/framework/http/logger.js";
+import { ensurePublicDir, hasUiBuild, uiIndexMiddleware, uiStaticMiddleware } from "@/framework/http/static.js";
+import { registerModuleRoutes } from "@/framework/modules/routes.js";
+import { loadProviders } from "@/framework/providers/loader.js";
+import { bootQueueJobs } from "@/framework/queue/queue.js";
+import { setupQueueDashboard } from "@/framework/queue/ui.js";
+import { initRedis } from "@/framework/redis/client.js";
+import { storage } from "@/framework/storage/storage.js";
+
+/**
+ * Why: Assembles app kernel and boots all framework dependencies.
+ * When: HTTP server startup.
+ * Where: Called by server runtime entrypoint.
+ * How: Initializes storage/db/redis/queues/events/routes and optional UI.
+ */
+export async function createKernel() {
+  validateConfig();
+
+  await storage.init();
+
+  await initRedis();
+
+  const app = createHttpApp();
+
+  await initDatabase();
+  await loadProviders();
+  await bootQueueJobs();
+  await registerModuleRoutes(app);
+
+  const queueDashboard = await setupQueueDashboard();
+  if (typeof queueDashboard.route === "function") {
+    queueDashboard.route(app);
+  } else {
+    app.use(queueDashboard.basePath, queueDashboard.route);
+  }
+
+  if (appConfig.uiEnabled) {
+    ensurePublicDir();
+  }
+
+  if (appConfig.uiEnabled && hasUiBuild()) {
+    app.use(uiStaticMiddleware);
+    app.get("*", uiIndexMiddleware);
+  }
+
+  app.use(notFound);
+  app.use(onError);
+
+  return { app, bullBoard: queueDashboard };
+}

package/express/src/framework/maker-cli/index.mjs

@@ -5,6 +5,7 @@ import { config } from "dotenv";
 import { registerDbCommands } from "./db/index.mjs";
 import { registerMiddlewareCommands } from "./middleware/index.mjs";
 import { registerModuleCommands } from "./module/index.mjs";
+import { registerProviderCommands } from "./provider/index.mjs";
 import { registerRuntimeCommands } from "./runtime/index.mjs";
 import { configureGroupedHelp, makerCommandPrefix, showHelp } from "./utils/help.mjs";
 import { registerProjectCommands } from "./utils/project-commands.mjs";
@@ -42,6 +43,7 @@ try {
 
   registerMiddlewareCommands(program, args);
   registerModuleCommands(program, args);
+  registerProviderCommands(program, args);
   registerDeployCommands(program, args);
   registerDbCommands(program, args);
   registerRuntimeCommands(program, args);

package/express/src/framework/maker-cli/module/core.mjs

@@ -45,6 +45,11 @@ const STUBS = {
   facade: {
     named: "facade/name.ts.stub"
   },
+  provider: {
+    named: "provider/name.ts.stub",
+    module: "provider/module.ts.stub",
+    moduleBarrel: "provider/module-barrel.ts.stub"
+  },
   helper: {
     named: "helper/name.ts.stub"
   },
@@ -739,6 +744,31 @@ export async function makeLocalMiddleware(rawModule, rawNameOrFlag, extraFlags =
   await writeFileSafe(path.join(root, `middlewares/${name}.ts`), content, flags, "Middleware file");
 }
 
+/**
+ * Generate a provider file for an existing module.
+ *
+ * The file lands in the module's providers/ folder, which the framework
+ * imports at boot just like src/providers/. That is what lets a module offer
+ * an implementation to the whole application without the application knowing
+ * anything about the module's internals.
+ */
+export async function makeModuleProvider(rawModule, rawNameOrFlag, extraFlags = []) {
+  const { moduleName, leaf } = resolveModuleRef(rawModule, rawNameOrFlag, extraFlags);
+  const { name, flags } = parseNameArg(rawNameOrFlag, extraFlags, "Provider name", leaf);
+  const root = await assertModuleExists(moduleName);
+  const filePath = path.join(root, `providers/${name}.ts`);
+  if (hasFlag(flags, "--dry-run")) {
+    console.log(`Would create provider file: ${path.relative(process.cwd(), filePath)}`);
+    return;
+  }
+  const content = await stub(STUBS.provider.module, {
+    module: moduleName,
+    name,
+    camel: camelCase(name)
+  });
+  await writeFileSafe(filePath, content, flags, "Provider file");
+}
+
 /** Generate a types file for an existing module. */
 export async function makeType(rawModule, rawNameOrFlag, extraFlags = []) {
   const { moduleName, leaf } = resolveModuleRef(rawModule, rawNameOrFlag, extraFlags);

package/express/src/framework/maker-cli/module/index.mjs

@@ -12,6 +12,7 @@ import {
   makeLocalMiddleware,
   makeModel,
   makeModule,
+  makeModuleProvider,
   makeModules,
   makeNotificationModule,
   makeRoute,
@@ -28,7 +29,7 @@ import {
 export function registerModuleCommands(program, rawArgs) {
   program
     .command("module:make <names...>")
-    .description("Create one or more modules with facade, schema, service, controller, route, model, and seeder folders")
+    .description("Create one or more modules with facade, providers, schema, service, controller, route, model, and seeder folders")
     .option("--path <panel>", "Nest the module(s) under a panel folder (e.g. --path=admin)")
     .option("--force", "Overwrite the files of modules that already exist")
     .allowUnknownOption(true)
@@ -128,6 +129,14 @@ export function registerModuleCommands(program, rawArgs) {
     .option("--path <panel>", "Address a module inside a panel folder (e.g. --path=admin)")
     .allowUnknownOption(true)
     .action(async (moduleName, name) => makeLocalMiddleware(moduleName, name, rawArgs.slice(name ? 3 : 2)));
+  program
+    .command("module:make-provider <module> [name]")
+    .description("Generate a provider file in the module's providers folder")
+    .option("--force", "Overwrite existing provider file")
+    .option("--dry-run", "Print what would be created without executing")
+    .option("--path <panel>", "Address a module inside a panel folder (e.g. --path=admin)")
+    .allowUnknownOption(true)
+    .action(async (moduleName, name) => makeModuleProvider(moduleName, name, rawArgs.slice(name ? 3 : 2)));
   program
     .command("module:make-type <module> [name]")
     .description("Generate a types file for an existing module")

package/express/src/framework/maker-cli/provider/core.mjs

@@ -0,0 +1,49 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { hasFlag } from "../utils/flags.mjs";
+import { assertName, camelCase } from "../utils/naming.mjs";
+
+const stubsRoot = path.resolve(import.meta.dirname, "../stubs");
+
+/** Read a stub file and replace {{key}} placeholders, removing unfilled ones. */
+async function stub(name, values = {}) {
+  let content = await fs.readFile(path.join(stubsRoot, name), "utf8");
+  for (const [key, value] of Object.entries(values)) {
+    content = content.replaceAll(`{{${key}}}`, String(value));
+  }
+  return content.replace(/\{\{[A-Z0-9_]+\}\}/g, "");
+}
+
+/**
+ * Why: Generates the app-wide provider file.
+ * When: A developer wants to plug an implementation into the whole app.
+ * Where: src/providers/<name>.ts - imported automatically at boot.
+ * How: Writes the stub and prints how to reach the provider from anywhere.
+ */
+export async function makeProvider(rawName, flags = []) {
+  const name = assertName(rawName, "Provider name");
+  const camel = camelCase(name);
+  const dryRun = hasFlag(flags, "--dry-run");
+  const force = hasFlag(flags, "--force") || hasFlag(flags, "--yes");
+
+  const filePath = path.resolve(process.cwd(), "src/providers", `${name}.ts`);
+  if (dryRun) {
+    console.log(`Would create provider file: ${path.relative(process.cwd(), filePath)}`);
+    return;
+  }
+
+  let exists = false;
+  try {
+    await fs.access(filePath);
+    exists = true;
+  } catch {}
+  if (exists && !force) {
+    throw new Error(`Provider already exists: ${path.relative(process.cwd(), filePath)}. Re-run with --force to overwrite.`);
+  }
+
+  const content = await stub("provider/name.ts.stub", { name, camel });
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+  console.log(`Provider ready: ${path.relative(process.cwd(), filePath)}`);
+  console.log(`It is imported at boot. Reach it with: getProvider("${name}")`);
+}

package/express/src/framework/maker-cli/provider/index.mjs

@@ -0,0 +1,12 @@
+import { makeProvider } from "./core.mjs";
+
+/** Register provider:* subcommands on the CLI program. */
+export function registerProviderCommands(program, rawArgs) {
+  program
+    .command("provider:make <name>")
+    .description("Generate a provider file in src/providers")
+    .option("--force", "Overwrite existing provider file")
+    .option("--dry-run", "Print what would be created without executing")
+    .allowUnknownOption(true)
+    .action(async (name) => makeProvider(name, rawArgs.filter((arg) => arg.startsWith("--"))));
+}

package/express/src/framework/maker-cli/stubs/notification/controller.ts.stub

@@ -1,77 +1,77 @@
-import { and, count, desc, eq, sql } from "drizzle-orm";
-import type { Request, Response } from "express";
-import { db } from "@/framework/facade.js";
-import { notifications } from "@/modules/auth/database/models/notifications.js";
-
-type AuthRequest = Request & { auth: { id: number } };
-
-export const list = async (req: AuthRequest, res: Response) => {
-  const userId = req.auth.id;
-  const page = Math.max(1, Number(req.query.page) || 1);
-  const perPage = Math.min(50, Math.max(1, Number(req.query.perPage) || 20));
-
-  const unread = await db.select({ count: count() }).from(notifications)
-    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
-  const total = await db.select({ count: count() }).from(notifications)
-    .where(eq(notifications.userId, userId));
-  const rows = await db.select().from(notifications)
-    .where(eq(notifications.userId, userId))
-    .orderBy(desc(notifications.createdAt))
-    .limit(perPage)
-    .offset((page - 1) * perPage);
-
-  res.json({
-    data: rows.map(normalize),
-    total: total[0].count,
-    unread: unread[0].count,
-    page,
-    perPage
-  });
-};
-
-export const unreadCount = async (req: AuthRequest, res: Response) => {
-  const userId = req.auth.id;
-  const rows = await db.select({ count: count() }).from(notifications)
-    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
-  res.json({ count: rows[0].count });
-};
-
-export const markRead = async (req: AuthRequest, res: Response) => {
-  const id = Number(req.params.id);
-  await db.update(notifications)
-    .set({ readAt: sql`now()` })
-    .where(and(eq(notifications.id, id), eq(notifications.userId, req.auth.id)));
-  res.json({ ok: true });
-};
-
-export const markAllRead = async (req: AuthRequest, res: Response) => {
-  await db.update(notifications)
-    .set({ readAt: sql`now()` })
-    .where(and(eq(notifications.userId, req.auth.id), sql`${notifications.readAt} IS NULL`));
-  res.json({ ok: true });
-};
-
-export const remove = async (req: AuthRequest, res: Response) => {
-  const id = Number(req.params.id);
-  await db.delete(notifications)
-    .where(and(eq(notifications.id, id), eq(notifications.userId, req.auth.id)));
-  res.json({ ok: true });
-};
-
-function normalize(row: typeof notifications.$inferSelect) {
-  let parsed: unknown = null;
-  if (row.data) {
-    try { parsed = JSON.parse(row.data); } catch {}
-  }
-  return {
-    id: row.id,
-    userId: row.userId,
-    type: row.type,
-    title: row.title,
-    body: row.body,
-    data: parsed,
-    link: row.link,
-    readAt: row.readAt?.toISOString() || null,
-    createdAt: row.createdAt.toISOString(),
-  };
-}
+import { and, count, desc, eq, sql } from "drizzle-orm";
+import type { Request, Response } from "express";
+import { db } from "@/framework/facade.js";
+import { notifications } from "@/modules/auth/database/models/notification.js";
+
+type AuthRequest = Request & { auth: { id: number } };
+
+export const list = async (req: AuthRequest, res: Response) => {
+  const userId = req.auth.id;
+  const page = Math.max(1, Number(req.query.page) || 1);
+  const perPage = Math.min(50, Math.max(1, Number(req.query.perPage) || 20));
+
+  const unread = await db.select({ count: count() }).from(notifications)
+    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+  const total = await db.select({ count: count() }).from(notifications)
+    .where(eq(notifications.userId, userId));
+  const rows = await db.select().from(notifications)
+    .where(eq(notifications.userId, userId))
+    .orderBy(desc(notifications.createdAt))
+    .limit(perPage)
+    .offset((page - 1) * perPage);
+
+  res.json({
+    data: rows.map(normalize),
+    total: total[0].count,
+    unread: unread[0].count,
+    page,
+    perPage
+  });
+};
+
+export const unreadCount = async (req: AuthRequest, res: Response) => {
+  const userId = req.auth.id;
+  const rows = await db.select({ count: count() }).from(notifications)
+    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+  res.json({ count: rows[0].count });
+};
+
+export const markRead = async (req: AuthRequest, res: Response) => {
+  const id = Number(req.params.id);
+  await db.update(notifications)
+    .set({ readAt: sql`now()` })
+    .where(and(eq(notifications.id, id), eq(notifications.userId, req.auth.id)));
+  res.json({ ok: true });
+};
+
+export const markAllRead = async (req: AuthRequest, res: Response) => {
+  await db.update(notifications)
+    .set({ readAt: sql`now()` })
+    .where(and(eq(notifications.userId, req.auth.id), sql`${notifications.readAt} IS NULL`));
+  res.json({ ok: true });
+};
+
+export const remove = async (req: AuthRequest, res: Response) => {
+  const id = Number(req.params.id);
+  await db.delete(notifications)
+    .where(and(eq(notifications.id, id), eq(notifications.userId, req.auth.id)));
+  res.json({ ok: true });
+};
+
+function normalize(row: typeof notifications.$inferSelect) {
+  let parsed: unknown = null;
+  if (row.data) {
+    try { parsed = JSON.parse(row.data); } catch {}
+  }
+  return {
+    id: row.id,
+    userId: row.userId,
+    type: row.type,
+    title: row.title,
+    body: row.body,
+    data: parsed,
+    link: row.link,
+    readAt: row.readAt?.toISOString() || null,
+    createdAt: row.createdAt.toISOString(),
+  };
+}

package/express/src/framework/maker-cli/stubs/provider/module-barrel.ts.stub

@@ -0,0 +1,19 @@
+/**
+ * Providers for the {{module}} module.
+ *
+ * This file is imported automatically at boot, so whatever it registers is
+ * available to the whole application. Use this to plug implementations (e.g.
+ * auth, payments) into the app - not to export the module's API to other
+ * modules (that is what facade.ts is for):
+ *
+ *   import { registerProvider } from "@/framework/facade.js";
+ *
+ *   registerProvider("{{module}}", { ... });
+ *
+ * A module with more than one provider keeps them in providers/*.ts instead -
+ * those files are imported at boot too.
+ *
+ * Rule: a module never imports another module's provider implementation.
+ */
+
+export {};

package/express/src/framework/maker-cli/stubs/provider/module.ts.stub

@@ -0,0 +1,21 @@
+import { registerProvider } from "@/framework/facade.js";
+
+/**
+ * Why: Plugs the {{name}} implementation into the application.
+ * When: Imported automatically at boot from each module's providers folder.
+ * Where: src/modules/{{module}}/providers/{{name}}.ts
+ *
+ * Reach it from anywhere in the app:
+ *
+ *   import { getProvider } from "@/framework/facade.js";
+ *   const {{camel}} = getProvider<typeof {{camel}}Provider>("{{name}}");
+ *
+ * Rule: a provider never imports another module's provider implementation.
+ */
+export const {{camel}}Provider = {
+  async handle(input: unknown) {
+    return input;
+  }
+};
+
+registerProvider("{{name}}", {{camel}}Provider);

package/express/src/framework/maker-cli/stubs/provider/name.ts.stub

@@ -0,0 +1,21 @@
+import { registerProvider } from "@/framework/facade.js";
+
+/**
+ * Why: Plugs the {{name}} implementation into the application.
+ * When: Imported automatically at boot from src/providers/.
+ * Where: src/providers/{{name}}.ts
+ *
+ * Reach it from anywhere in the app:
+ *
+ *   import { getProvider } from "@/framework/facade.js";
+ *   const {{camel}} = getProvider<typeof {{camel}}Provider>("{{name}}");
+ *
+ * Rule: a provider never imports another provider's implementation.
+ */
+export const {{camel}}Provider = {
+  async handle(input: unknown) {
+    return input;
+  }
+};
+
+registerProvider("{{name}}", {{camel}}Provider);

package/express/src/framework/maker-cli/utils/help.mjs

@@ -89,7 +89,11 @@ const COMMAND_GROUPS = [
     // `module:make-middleware` writes inside one module and applies only to it.
     // In the same section the two look interchangeable, which is exactly the
     // mistake a developer is about to make.
-    commands: ["middleware:make"]
+    //
+    // `provider:make` follows the same split: it writes to src/providers and
+    // applies to the whole app, `module:make-provider` writes inside one
+    // module and applies only to it.
+    commands: ["middleware:make", "provider:make"]
   },
   {
     title: "Generators - modules",
@@ -107,6 +111,7 @@ const COMMAND_GROUPS = [
       "module:make-test",
       "module:make-helper",
       "module:make-middleware",
+      "module:make-provider",
       "module:make-type"
     ]
   },

package/express/src/framework/maker-cli/utils/project-commands.mjs

@@ -13,8 +13,16 @@ import { PROJECT_COMMAND_FLAG } from "./help.mjs";
  * there would be overwritten on the next framework update - and `src/modules/`
  * is swept by the route, job and seeder globs. The project root is the one
  * place nothing else owns.
+ *
+ * Two names are read: commands.mjs (plain JavaScript, loaded by plain node)
+ * and commands.ts (TypeScript, loaded through tsx). The .mjs is the incumbent
+ * and wins if a project keeps both.
  */
 export const PROJECT_COMMANDS_PATH = "maker/commands.mjs";
+export const PROJECT_COMMANDS_TS_PATH = "maker/commands.ts";
+
+/** Process-global so a re-evaluated module cannot register tsx twice. */
+const TSX_REGISTERED = "__nexwireMakerTsxRegistered";
 
 const PROJECT_COMMANDS_TEMPLATE = `/**
  * Your project's maker commands.
@@ -36,8 +44,11 @@ const PROJECT_COMMANDS_TEMPLATE = `/**
  *     which one. Rename yours; the built-in stays.
  *   - An error in this file is reported, never swallowed. If your commands stop
  *     appearing, the fault is here rather than in your command code.
- *   - Import your own code with a normal relative path, e.g.
- *       import { sendInvoice } from "../src/invoices/send.js";
+ *   - This file runs as plain JavaScript under plain Node, so it cannot import
+ *     your TypeScript source or use your tsconfig path alias. If a command
+ *     needs either, name this file maker/commands.ts instead and delete this
+ *     one - nexwire loads that file through tsx, with your tsconfig applied.
+ *     For editor type support, create maker/tsconfig.json as shown in the docs.
  *
  * Replace or delete the example below once you have a command of your own.
  */
@@ -54,14 +65,47 @@ export default function register(program) {
 }
 `;
 
+/**
+ * Why: Plain node cannot import TypeScript, so maker/commands.ts needs tsx
+ *      registered before it is imported. Registered at most once per process
+ *      and never unregistered: two overlapping registrations corrupt the
+ *      loader, and commands routinely import more TypeScript at action time,
+ *      long after this function returns. The flag lives on globalThis because
+ *      this module can be evaluated more than once in one process (vitest's
+ *      per-file isolation) while the loader hooks are process-wide.
+ * When: Only when the project's file is TypeScript - maker/commands.mjs never
+ *      pays for tsx being installed.
+ * Where: utils/project-commands.mjs.
+ */
+async function registerTsLoader(rel) {
+  if (globalThis[TSX_REGISTERED]) return;
+
+  try {
+    const { register } = await import("tsx/esm/api");
+    register();
+  } catch (error) {
+    throw new Error(
+      `${rel} needs tsx to load TypeScript, but it could not be registered: ${error?.message || error}. tsx ships as a devDependency of every nexwire project - run npm install, or rename the file to ${PROJECT_COMMANDS_PATH}.`,
+      { cause: error }
+    );
+  }
+
+  globalThis[TSX_REGISTERED] = true;
+}
+
 /**
  * Why: Registers the commands a project defined for itself.
  * When: Every maker invocation, right after the framework's own registrars.
  * Where: Maker CLI entry flow, from utils/project-commands.mjs.
- * How: Imports maker/commands.mjs resolved from process.cwd() - not from
- *      import.meta.dirname, which points inside node_modules and would find the
- *      framework's own directory instead of the project. Absent is silent and
- *      free; broken is loud, because a developer's commands silently not
+ * How: Imports maker/commands.mjs - or maker/commands.ts, loaded through tsx,
+ *      which resolves the project's tsconfig path aliases - resolved from
+ *      process.cwd(), not from import.meta.dirname, which points inside
+ *      node_modules and would find the framework's own directory instead of the
+ *      project. If a project keeps both files the .mjs wins and the .ts file is
+ *      skipped with a warning naming it, so neither file is ever silently dead:
+ *      a project that already runs must not be re-registered by a file that
+ *      appeared later, and a file that is skipped must say so. Absent is silent
+ *      and free; broken is loud, because a developer's commands silently not
  *      existing is a far worse experience than an error message. A name that
  *      collides with a framework command is refused by commander itself, which
  *      is the right outcome: the built-in wins and the project cannot shadow a
@@ -70,10 +114,23 @@ export default function register(program) {
  *      asked for the name.
  */
 export async function registerProjectCommands(program, rawArgs, cwd = process.cwd()) {
-  const file = path.resolve(cwd, PROJECT_COMMANDS_PATH);
+  const mjsFile = path.resolve(cwd, PROJECT_COMMANDS_PATH);
+  const tsFile = path.resolve(cwd, PROJECT_COMMANDS_TS_PATH);
+  const hasMjs = fs.existsSync(mjsFile);
+  const hasTs = fs.existsSync(tsFile);
+
+  if (!hasMjs && !hasTs) {
+    return { loaded: false, file: mjsFile, added: [] };
+  }
+
+  const isTs = !hasMjs && hasTs;
+  const file = isTs ? tsFile : mjsFile;
+  const rel = isTs ? PROJECT_COMMANDS_TS_PATH : PROJECT_COMMANDS_PATH;
 
-  if (!fs.existsSync(file)) {
-    return { loaded: false, file, added: [] };
+  if (hasMjs && hasTs) {
+    console.warn(
+      `${PROJECT_COMMANDS_TS_PATH} is ignored because ${PROJECT_COMMANDS_PATH} exists. Keep one - delete the file you are not using.`
+    );
   }
 
   // Not wrapped in a bare try/catch on purpose. A file that exists but fails to
@@ -81,18 +138,22 @@ export async function registerProjectCommands(program, rawArgs, cwd = process.cw
   // command that is actually in this loader. The catches below only attach the
   // file name, because an error from inside the project file otherwise reads as
   // if it came from the framework.
+  if (isTs) {
+    await registerTsLoader(rel);
+  }
+
   let module;
   try {
     module = await import(pathToFileURL(file).href);
   } catch (error) {
-    throw new Error(`Could not load ${PROJECT_COMMANDS_PATH}: ${error?.message || error}`, { cause: error });
+    throw new Error(`Could not load ${rel}: ${error?.message || error}`, { cause: error });
   }
 
   const register = module.default ?? module.register;
 
   if (typeof register !== "function") {
     throw new TypeError(
-      `${PROJECT_COMMANDS_PATH} must export a default function (program, args) => void. Found: ${typeof register}.`
+      `${rel} must export a default function (program, args) => void. Found: ${typeof register}.`
     );
   }
 
@@ -101,7 +162,7 @@ export async function registerProjectCommands(program, rawArgs, cwd = process.cw
   try {
     await register(program, rawArgs);
   } catch (error) {
-    throw new Error(`Could not register commands from ${PROJECT_COMMANDS_PATH}: ${error?.message || error}`, {
+    throw new Error(`Could not register commands from ${rel}: ${error?.message || error}`, {
       cause: error
     });
   }