@impulselab/cli 0.1.0

package/src/transforms/register-route.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm } from "fs/promises";
+import { outputFile, readFile } from "fs-extra";
+import path from "path";
+import os from "os";
+import { registerRoute } from "./register-route";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(path.join(os.tmpdir(), "impulse-route-test-"));
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+const satisfiesRouter = `import { createRouter } from "@orpc/server";
+import { healthRouter } from "./health";
+
+export const appRouter = createRouter({
+  health: healthRouter,
+} satisfies RouterInput);
+`;
+
+const asRouter = `import { createRouter } from "@orpc/server";
+import { healthRouter } from "./health";
+
+export const appRouter = {
+  health: healthRouter,
+} as AppRouter;
+`;
+
+// Router that contains an inline `as` type cast inside a nested expression
+// — the fix must NOT insert into the inline cast.
+const routerWithInlineAs = `import { createRouter } from "@orpc/server";
+
+function helper(x: unknown) {
+  return (x as string).toUpperCase();
+}
+
+export const appRouter = createRouter({
+  health: healthRouter,
+} satisfies RouterInput);
+`;
+
+// Router where another typed object's `}` appears on its own line before
+// `satisfies`/`as` on the next line — cross-line match must be avoided.
+const routerWithCrossLineSatisfies = `const config = {
+  setting: true,
+}
+satisfies ConfigType;
+
+export const appRouter = createRouter({
+  health: healthRouter,
+} satisfies RouterInput);
+`;
+
+describe("registerRoute", () => {
+  it("inserts route into a 'satisfies' router", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, satisfiesRouter);
+
+    await registerRoute(
+      "src/server/api/router.ts",
+      "auth: authRouter",
+      tmpDir,
+      false
+    );
+
+    const result = await readFile(routerFile, "utf-8");
+    expect(result).toContain("auth: authRouter");
+    expect(result).toContain("health: healthRouter");
+  });
+
+  it("inserts route into an 'as' router", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, asRouter);
+
+    await registerRoute(
+      "src/server/api/router.ts",
+      "auth: authRouter",
+      tmpDir,
+      false
+    );
+
+    const result = await readFile(routerFile, "utf-8");
+    expect(result).toContain("auth: authRouter");
+  });
+
+  it("does not match when } and satisfies/as are on separate lines (cross-line false match)", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, routerWithCrossLineSatisfies);
+
+    await registerRoute(
+      "src/server/api/router.ts",
+      "auth: authRouter",
+      tmpDir,
+      false
+    );
+
+    const result = await readFile(routerFile, "utf-8");
+    // Route must appear near the appRouter closing, not near the config object
+    const insertIdx = result.indexOf("auth: authRouter");
+    const configSatisfiesIdx = result.indexOf("}\nsatisfies ConfigType");
+    expect(insertIdx).toBeGreaterThan(configSatisfiesIdx);
+  });
+
+  it("does not match inline 'as' casts inside nested expressions", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, routerWithInlineAs);
+
+    await registerRoute(
+      "src/server/api/router.ts",
+      "auth: authRouter",
+      tmpDir,
+      false
+    );
+
+    const result = await readFile(routerFile, "utf-8");
+    // Route must appear just before `} satisfies`, not before `} as string`
+    const insertIdx = result.indexOf("auth: authRouter");
+    const satisfiesIdx = result.indexOf("} satisfies");
+    expect(insertIdx).toBeGreaterThan(-1);
+    expect(insertIdx).toBeLessThan(satisfiesIdx);
+  });
+
+  it("does not insert duplicate routes", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, satisfiesRouter);
+
+    await registerRoute(
+      "src/server/api/router.ts",
+      "health: healthRouter",
+      tmpDir,
+      false
+    );
+
+    const result = await readFile(routerFile, "utf-8");
+    expect(result.split("health: healthRouter").length - 1).toBe(1);
+  });
+
+  it("does not write file in dry-run mode", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, satisfiesRouter);
+
+    await registerRoute(
+      "src/server/api/router.ts",
+      "auth: authRouter",
+      tmpDir,
+      true
+    );
+
+    const result = await readFile(routerFile, "utf-8");
+    expect(result).toBe(satisfiesRouter);
+  });
+
+  it("throws if file not found", async () => {
+    await expect(
+      registerRoute("nonexistent/router.ts", "auth: authRouter", tmpDir, false)
+    ).rejects.toThrow("target file not found");
+  });
+
+  it("throws if no router closing brace found", async () => {
+    const routerFile = path.join(tmpDir, "src/server/api/router.ts");
+    await outputFile(routerFile, `export const foo = "bar";\n`);
+
+    await expect(
+      registerRoute(
+        "src/server/api/router.ts",
+        "auth: authRouter",
+        tmpDir,
+        false
+      )
+    ).rejects.toThrow("could not find router closing brace");
+  });
+});

package/src/transforms/register-route.ts

@@ -0,0 +1,47 @@
+import fsExtra from "fs-extra";
+const { readFile, outputFile, pathExists } = fsExtra;
+import path from "path";
+
+/**
+ * Registers an oRPC route in the router file.
+ * target: path to the router file (e.g. "src/server/api/router.ts")
+ * value: the route line to add (e.g. "auth: authRouter")
+ */
+export async function registerRoute(
+  target: string,
+  value: string,
+  cwd: string,
+  dryRun: boolean
+): Promise<void> {
+  const file = path.join(cwd, target);
+
+  if (!(await pathExists(file))) {
+    throw new Error(
+      `register-route: target file not found: ${target}. Please ensure your router file exists.`
+    );
+  }
+
+  const content = await readFile(file, "utf-8");
+  if (content.includes(value)) return;
+
+  // Find the router object closing brace and insert before it.
+  // Anchored to start-of-line (multiline) with [ \t]* (no newlines) to avoid
+  // matching `}` on one line with `satisfies`/`as` on a subsequent line.
+  const routerPattern = /^([ \t]*\})[ \t]*(?:satisfies|as)\s/m;
+  const match = routerPattern.exec(content);
+
+  if (!match) {
+    throw new Error(
+      `register-route: could not find router closing brace in ${target}. Add "${value}" manually.`
+    );
+  }
+
+  if (!dryRun) {
+    const insertPos = match.index;
+    const newContent =
+      content.slice(0, insertPos) +
+      `  ${value},\n` +
+      content.slice(insertPos);
+    await outputFile(file, newContent, "utf-8");
+  }
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+export { ModuleFileSchema } from "./schemas/module-file";
+export type { ModuleFile } from "./schemas/module-file";
+export { ModuleDependencySchema } from "./schemas/module-dependency";
+export { ModuleTransformSchema } from "./schemas/module-transform";
+export type { ModuleTransform } from "./schemas/module-transform";
+export { ModuleManifestSchema } from "./schemas/module-manifest";
+export type { ModuleManifest } from "./schemas/module-manifest";
+export { ImpulseConfigSchema } from "./schemas/impulse-config";
+export type { ImpulseConfig } from "./schemas/impulse-config";

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}