effect-start 0.23.0 → 0.25.0

package/dist/FileRouterCodegen.js

@@ -1,227 +1,298 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import * as FileSystem from "./FileSystem.js";
-import * as Effect from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Schema from "effect/Schema";
-import * as NPath from "node:path";
-import * as FilePathPattern from "./FilePathPattern.js";
-import * as FileRouter from "./FileRouter.js";
-import * as SchemaExtra from "./SchemaExtra.js";
+import * as FileSystem from "./FileSystem.js"
+import * as Effect from "effect/Effect"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import * as NPath from "node:path"
+import * as FilePathPattern from "./FilePathPattern.js"
+import * as FileRouter from "./FileRouter.js"
+import * as SchemaExtra from "./SchemaExtra.js"
+
 export function validateRouteModule(module) {
-    if (typeof module !== "object" || module === null) {
-        return false;
-    }
-    if (!("default" in module)) {
-        return false;
-    }
-    // TODO: verify we're exporting a proper shape
-    return true;
+  if (typeof module !== "object" || module === null) {
+    return false
+  }
+
+  if (!("default" in module)) {
+    return false
+  }
+
+  // TODO: verify we're exporting a proper shape
+  return true
 }
-export function generatePathParamsSchema(segments) {
-    const fields = {};
-    for (const segment of segments) {
-        if (segment._tag === "ParamSegment") {
-            fields[segment.name] = Schema.String;
-        }
-        else if (segment._tag === "RestSegment") {
-            fields[segment.name] = Schema.optional(Schema.String);
-        }
-    }
-    if (Object.keys(fields).length === 0) {
-        return null;
+
+export function generatePathParamsSchema(
+  segments,
+) {
+  const fields = {}
+
+  for (const segment of segments) {
+    if (segment._tag === "ParamSegment") {
+      fields[segment.name] = Schema.String
+    } else if (segment._tag === "RestSegment") {
+      fields[segment.name] = Schema.optional(Schema.String)
     }
-    return Schema.Struct(fields);
+  }
+
+  if (Object.keys(fields).length === 0) {
+    return null
+  }
+
+  return Schema.Struct(fields)
 }
+
 /**
  * Validates all route modules in the given route handles.
  */
-export function validateRouteModules(path, routes) {
-    return Effect.gen(function* () {
-        const fs = yield* FileSystem.FileSystem;
-        const routeHandles = routes.filter((h) => h.handle === "route");
-        for (const handle of routeHandles) {
-            const routeModulePath = NPath.resolve(path, handle.modulePath);
-            const expectedSchema = generatePathParamsSchema(handle.segments);
-            const fileExists = yield* fs
-                .exists(routeModulePath)
-                .pipe(Effect.catchAll(() => Effect.succeed(false)));
-            if (!fileExists) {
-                continue;
-            }
-            const module = yield* Effect.tryPromise({
-                try: () => import(__rewriteRelativeImportExtension(routeModulePath)),
-                catch: (cause) => new FileRouter.FileRouterError({
-                    reason: "Import",
-                    cause,
-                    path: routeModulePath,
-                }),
-            });
-            if (!validateRouteModule(module)) {
-                yield* Effect.logWarning(`Route module ${routeModulePath} should export default Route`);
-                continue;
-            }
-            const routeSet = module.default;
-            // extract user schema
-            const userSchema = undefined;
-            if (expectedSchema && userSchema && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
-                const relativeFilePath = NPath.relative(process.cwd(), routeModulePath);
-                yield* Effect.logError(`Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${SchemaExtra.formatSchemaCode(expectedSchema)})`);
-            }
-        }
-    });
+
+export function validateRouteModules(
+  path,
+  routes,
+) {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const routeHandles = routes.filter((h) => h.handle === "route")
+
+    for (const handle of routeHandles) {
+      const routeModulePath = NPath.resolve(path, handle.modulePath)
+      const expectedSchema = generatePathParamsSchema(handle.segments)
+
+      const fileExists = yield* fs
+        .exists(routeModulePath)
+        .pipe(Effect.catchAll(() => Effect.succeed(false)))
+      if (!fileExists) {
+        continue
+      }
+
+      const module = yield* Effect.tryPromise({
+        try: () => import(routeModulePath),
+        catch: (cause) =>
+          new FileRouter.FileRouterError({
+            reason: "Import",
+            cause,
+            path: routeModulePath,
+          }),
+      })
+
+      if (!validateRouteModule(module)) {
+        yield* Effect.logWarning(`Route module ${routeModulePath} should export default Route`)
+        continue
+      }
+
+      const routeSet = module.default
+      // extract user schema
+      const userSchema = undefined
+
+      if (expectedSchema && userSchema && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
+        const relativeFilePath = NPath.relative(process.cwd(), routeModulePath)
+        yield* Effect.logError(
+          `Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${SchemaExtra.formatSchemaCode(
+            expectedSchema,
+          )})`,
+        )
+      }
+    }
+  })
 }
+
 export function generateCode(fileRoutes) {
-    // Group routes by path to find layers
-    const routesByPath = new Map();
-    for (const fileRoute of fileRoutes) {
-        const existing = routesByPath.get(fileRoute.routePath) || { layers: [] };
-        if (fileRoute.handle === "route") {
-            existing.route = fileRoute;
-        }
-        else if (fileRoute.handle === "layer") {
-            existing.layers.push(fileRoute);
-        }
-        routesByPath.set(fileRoute.routePath, existing);
+  // Group routes by path to find layers
+  const routesByPath = new Map()
+
+  for (const fileRoute of fileRoutes) {
+    const existing = routesByPath.get(fileRoute.routePath) || { layers: [] }
+    if (fileRoute.handle === "route") {
+      existing.route = fileRoute
+    } else if (fileRoute.handle === "layer") {
+      existing.layers.push(fileRoute)
     }
-    // Helper to check if layer's path is an ancestor of route's path
-    const layerMatchesRoute = (layer, route) => {
-        const layerDir = layer.modulePath.replace(/\/(layer)\.(tsx?|jsx?)$/, "");
-        if (layerDir === "/")
-            return true;
-        return route.modulePath.startsWith(layerDir + "/");
-    };
-    // Build entries for each route path
-    const entries = [];
-    for (const [path, { route }] of routesByPath) {
-        if (!route)
-            continue;
-        // Collect all parent layers that match the route's groups
-        const allLayers = [];
-        let currentPath = path;
-        while (true) {
-            const pathData = routesByPath.get(currentPath);
-            if (pathData?.layers) {
-                const matchingLayers = pathData.layers.filter((layer) => layerMatchesRoute(layer, route));
-                allLayers.unshift(...matchingLayers);
-            }
-            if (currentPath === "/")
-                break;
-            const parentPath = currentPath.substring(0, currentPath.lastIndexOf("/"));
-            currentPath = parentPath || "/";
-        }
-        // Convert file-style path to colon-style PathPattern
-        const pathPatternResult = FilePathPattern.toPathPattern(path);
-        if (Either.isLeft(pathPatternResult)) {
-            continue;
-        }
-        const pathPattern = pathPatternResult.right;
-        // Order: route first, then layers from innermost to outermost
-        const loaders = [
-            `() => import(".${route.modulePath}")`,
-            ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
-        ];
-        entries.push({ path: pathPattern, loaders });
+    routesByPath.set(fileRoute.routePath, existing)
+  }
+
+  // Helper to check if layer's path is an ancestor of route's path
+  const layerMatchesRoute = (layer, route) => {
+    const layerDir = layer.modulePath.replace(/\/(layer)\.(tsx?|jsx?)$/, "")
+    if (layerDir === "/") return true
+    return route.modulePath.startsWith(layerDir + "/")
+  }
+
+  // Build entries for each route path
+  const entries = []
+
+  for (const [path, { route }] of routesByPath) {
+    if (!route) continue
+
+    // Collect all parent layers that match the route's groups
+    const allLayers = []
+    let currentPath = path
+
+    while (true) {
+      const pathData = routesByPath.get(currentPath)
+      if (pathData?.layers) {
+        const matchingLayers = pathData.layers.filter((layer) => layerMatchesRoute(layer, route))
+        allLayers.unshift(...matchingLayers)
+      }
+
+      if (currentPath === "/") break
+
+      const parentPath = currentPath.substring(0, currentPath.lastIndexOf("/"))
+      currentPath = parentPath || "/"
     }
-    // No routes found - don't create file
-    if (entries.length === 0) {
-        return null;
+
+    // Convert file-style path to colon-style PathPattern
+    const pathPatternResult = FilePathPattern.toPathPattern(path)
+    if (Either.isLeft(pathPatternResult)) {
+      continue
     }
-    const routeEntries = entries
-        .map(({ path, loaders }) => {
-        const loadersCode = loaders.join(",\n    ");
-        return `  "${path}": [\n    ${loadersCode},\n  ]`;
+    const pathPattern = pathPatternResult.right
+
+    // Order: route first, then layers from innermost to outermost
+    const loaders = [
+      `() => import(".${route.modulePath}")`,
+      ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
+    ]
+
+    entries.push({ path: pathPattern, loaders })
+  }
+
+  // No routes found - don't create file
+  if (entries.length === 0) {
+    return null
+  }
+
+  const routeEntries = entries
+    .map(({ path, loaders }) => {
+      const loadersCode = loaders.join(",\n    ")
+      return `  "${path}": [\n    ${loadersCode},\n  ]`
     })
-        .join(",\n");
-    return `/**
+    .join(",\n")
+
+  return `/**
  * Auto-generated by effect-start.
  */
 
 export default {
 ${routeEntries},
 } satisfies import("effect-start/FileRouter").FileRoutes
-`;
+`
 }
+
 /**
  * Updates the tree file only if the generated content differs from the existing file.
  * This prevents infinite loops when watching for file changes.
  */
-export function update(routesPath, treePath = "server.gen.ts") {
-    return Effect.gen(function* () {
-        treePath = NPath.resolve(routesPath, treePath);
-        const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+export function update(
+  routesPath,
+  treePath = "server.gen.ts",
+) {
+  return Effect.gen(function* () {
+    treePath = NPath.resolve(routesPath, treePath)
+
+    const fs = yield* FileSystem.FileSystem
+    const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
+      Effect.mapError(
+        (cause) =>
+          new FileRouter.FileRouterError({
             reason: "FileSystem",
             cause,
             path: routesPath,
-        })));
-        const fileRoutes = yield* FileRouter.getFileRoutes(files);
-        // Validate route modules
-        yield* validateRouteModules(routesPath, fileRoutes);
-        const newCode = generateCode(fileRoutes);
-        // Check if file exists (ok to fail - means file doesn't exist)
-        const existingCode = yield* fs
-            .readFileString(treePath)
-            .pipe(Effect.catchAll(() => Effect.succeed(null)));
-        // No routes found
-        if (newCode === null) {
-            // If gen file exists, write empty export
-            if (existingCode !== null) {
-                const emptyCode = "export default {}\n";
-                if (existingCode !== emptyCode) {
-                    yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`);
-                    yield* fs.writeFileString(treePath, emptyCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
-                        reason: "FileSystem",
-                        cause,
-                        path: treePath,
-                    })));
-                }
-            }
-            return;
-        }
-        // Write if content differs
-        if (existingCode !== newCode) {
-            yield* Effect.logDebug(`Updating file routes tree: ${treePath}`);
-            yield* fs.writeFileString(treePath, newCode).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
-                reason: "FileSystem",
-                cause,
-                path: treePath,
-            })));
-        }
-        else {
-            yield* Effect.logDebug(`File routes tree unchanged: ${treePath}`);
+          }),
+      ),
+    )
+    const fileRoutes = yield* FileRouter.getFileRoutes(files)
+
+    // Validate route modules
+    yield* validateRouteModules(routesPath, fileRoutes)
+
+    const newCode = generateCode(fileRoutes)
+
+    // Check if file exists (ok to fail - means file doesn't exist)
+    const existingCode = yield* fs
+      .readFileString(treePath)
+      .pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+    // No routes found
+    if (newCode === null) {
+      // If gen file exists, write empty export
+      if (existingCode !== null) {
+        const emptyCode = "export default {}\n"
+        if (existingCode !== emptyCode) {
+          yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`)
+          yield* fs.writeFileString(treePath, emptyCode).pipe(
+            Effect.mapError(
+              (cause) =>
+                new FileRouter.FileRouterError({
+                  reason: "FileSystem",
+                  cause,
+                  path: treePath,
+                }),
+            ),
+          )
         }
-    });
+      }
+      return
+    }
+
+    // Write if content differs
+    if (existingCode !== newCode) {
+      yield* Effect.logDebug(`Updating file routes tree: ${treePath}`)
+      yield* fs.writeFileString(treePath, newCode).pipe(
+        Effect.mapError(
+          (cause) =>
+            new FileRouter.FileRouterError({
+              reason: "FileSystem",
+              cause,
+              path: treePath,
+            }),
+        ),
+      )
+    } else {
+      yield* Effect.logDebug(`File routes tree unchanged: ${treePath}`)
+    }
+  })
 }
-export function dump(routesPath, treePath = "server.gen.ts") {
-    return Effect.gen(function* () {
-        treePath = NPath.resolve(routesPath, treePath);
-        const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+
+export function dump(
+  routesPath,
+  treePath = "server.gen.ts",
+) {
+  return Effect.gen(function* () {
+    treePath = NPath.resolve(routesPath, treePath)
+
+    const fs = yield* FileSystem.FileSystem
+    const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
+      Effect.mapError(
+        (cause) =>
+          new FileRouter.FileRouterError({
             reason: "FileSystem",
             cause,
             path: routesPath,
-        })));
-        const fileRoutes = yield* FileRouter.getFileRoutes(files);
-        // Validate route modules
-        yield* validateRouteModules(routesPath, fileRoutes);
-        const code = generateCode(fileRoutes);
-        // No routes found - don't create file
-        if (code === null) {
-            yield* Effect.logDebug(`No routes found, skipping: ${treePath}`);
-            return;
-        }
-        yield* Effect.logDebug(`Generating file routes tree: ${treePath}`);
-        yield* fs.writeFileString(treePath, code).pipe(Effect.mapError((cause) => new FileRouter.FileRouterError({
+          }),
+      ),
+    )
+    const fileRoutes = yield* FileRouter.getFileRoutes(files)
+
+    // Validate route modules
+    yield* validateRouteModules(routesPath, fileRoutes)
+
+    const code = generateCode(fileRoutes)
+
+    // No routes found - don't create file
+    if (code === null) {
+      yield* Effect.logDebug(`No routes found, skipping: ${treePath}`)
+      return
+    }
+
+    yield* Effect.logDebug(`Generating file routes tree: ${treePath}`)
+
+    yield* fs.writeFileString(treePath, code).pipe(
+      Effect.mapError(
+        (cause) =>
+          new FileRouter.FileRouterError({
             reason: "FileSystem",
             cause,
             path: treePath,
-        })));
-    });
+          }),
+      ),
+    )
+  })
 }