effect-start 0.23.1 → 0.26.0

package/dist/FilePathPattern.js

@@ -1,86 +0,0 @@
-import * as Either from "effect/Either";
-export function segments(pattern) {
-    const parts = pattern.split("/").filter(Boolean);
-    const result = [];
-    for (const part of parts) {
-        if (/^\(\w+\)$/.test(part)) {
-            result.push({ _tag: "GroupSegment", name: part.slice(1, -1) });
-        }
-        else if (part.startsWith("[[") && part.endsWith("]]")) {
-            result.push({ _tag: "RestSegment", name: part.slice(2, -2) });
-        }
-        else if (part.startsWith("[") && part.endsWith("]")) {
-            result.push({ _tag: "ParamSegment", name: part.slice(1, -1) });
-        }
-        else if (/^[\p{L}\p{N}._~-]+$/u.test(part)) {
-            result.push({ _tag: "LiteralSegment", value: part });
-        }
-        else {
-            result.push({ _tag: "InvalidSegment", value: part });
-        }
-    }
-    return result;
-}
-export function validate(pattern) {
-    const segs = segments(pattern);
-    const invalid = segs.find((s) => s._tag === "InvalidSegment");
-    if (invalid) {
-        return Either.left({
-            _tag: "FilePathPatternError",
-            pattern,
-            message: `Invalid segment: "${invalid.value}"`,
-        });
-    }
-    const restIndex = segs.findIndex((s) => s._tag === "RestSegment");
-    if (restIndex !== -1 && restIndex !== segs.length - 1) {
-        return Either.left({
-            _tag: "FilePathPatternError",
-            pattern,
-            message: "Rest segment must be the last segment",
-        });
-    }
-    return Either.right(segs);
-}
-export function format(segs) {
-    const parts = segs.map((seg) => {
-        switch (seg._tag) {
-            case "GroupSegment":
-                return `(${seg.name})`;
-            case "RestSegment":
-                return `[[${seg.name}]]`;
-            case "ParamSegment":
-                return `[${seg.name}]`;
-            case "LiteralSegment":
-                return seg.value;
-            case "InvalidSegment":
-                return seg.value;
-        }
-    });
-    const joined = parts.join("/");
-    return (joined ? `/${joined}` : "/");
-}
-export function toPathPattern(pattern) {
-    const result = validate(pattern);
-    if (Either.isLeft(result)) {
-        return Either.left(result.left);
-    }
-    const segs = result.right;
-    const pathParts = [];
-    for (const seg of segs) {
-        switch (seg._tag) {
-            case "GroupSegment":
-                continue;
-            case "RestSegment":
-                pathParts.push(`:${seg.name}*`);
-                break;
-            case "ParamSegment":
-                pathParts.push(`:${seg.name}`);
-                break;
-            case "LiteralSegment":
-                pathParts.push(seg.value);
-                break;
-        }
-    }
-    const joined = pathParts.join("/");
-    return Either.right((joined ? `/${joined}` : "/"));
-}

package/dist/FileRouter.d.ts

@@ -1,56 +0,0 @@
-import * as FileSystem from "./FileSystem.ts";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as FilePathPattern from "./FilePathPattern.ts";
-import type * as PathPattern from "./PathPattern.ts";
-import type * as PlatformError from "./PlatformError.ts";
-import * as Route from "./Route.ts";
-import * as RouteTree from "./RouteTree.ts";
-declare const FileRouterError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "FileRouterError";
-} & Readonly<A>;
-export declare class FileRouterError extends FileRouterError_base<{
-    reason: "Import" | "Conflict" | "FileSystem";
-    cause?: unknown;
-    path?: string;
-}> {
-}
-export type RouteModule = {
-    default: Route.RouteSet.Any;
-};
-export type LazyRouteModule = () => Promise<RouteModule>;
-export type FileRoutes = {
-    [path: PathPattern.PathPattern]: [LazyRouteModule, ...LazyRouteModule[]];
-};
-export type Segment = FilePathPattern.Segment;
-export type FileRoute = {
-    handle: "route" | "layer";
-    modulePath: `/${string}`;
-    routePath: `/${string}`;
-    segments: Array<Segment>;
-};
-/**
- * Routes sorted by depth, with rest parameters at the end.
- * - layer.tsx
- * - users/route.tsx
- * - users/[userId]/route.tsx
- * - [[rest]]/route.tsx
- */
-export type OrderedFileRoutes = Array<FileRoute>;
-export declare function parseRoute(path: string): FileRoute | null;
-/**
- * Generates a tree file that references all routes.
- */
-export declare function layer(load: () => Promise<{
-    default: FileRoutes;
-}>): Layer.Layer<Route.Routes, FileRouterError, FileSystem.FileSystem>;
-export declare function layer(options: {
-    load: () => Promise<{
-        default: FileRoutes;
-    }>;
-    path: string;
-}): Layer.Layer<Route.Routes, FileRouterError, FileSystem.FileSystem>;
-export declare function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.RouteTree>;
-export declare function walkRoutesDirectory(dir: string): Effect.Effect<OrderedFileRoutes, PlatformError.PlatformError | FileRouterError, FileSystem.FileSystem>;
-export declare function getFileRoutes(paths: Array<string>): Effect.Effect<OrderedFileRoutes, FileRouterError>;
-export {};

package/dist/FileRouter.js

@@ -1,148 +0,0 @@
-import * as FileSystem from "./FileSystem.js";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Stream from "effect/Stream";
-import * as NPath from "node:path";
-import * as NUrl from "node:url";
-import * as Development from "./Development.js";
-import * as FilePathPattern from "./FilePathPattern.js";
-import * as FileRouterCodegen from "./FileRouterCodegen.js";
-import * as NodeUtils from "./node/NodeUtils.js";
-import * as Route from "./Route.js";
-import * as RouteTree from "./RouteTree.js";
-export class FileRouterError extends Data.TaggedError("FileRouterError") {
-}
-const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/;
-export function parseRoute(path) {
-    const segs = FilePathPattern.segments(path);
-    const lastSeg = segs.at(-1);
-    const handleMatch = lastSeg?._tag === "LiteralSegment" && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/);
-    const handle = handleMatch ? handleMatch[1] : null;
-    if (!handle) {
-        return null;
-    }
-    const pathSegments = segs.slice(0, -1);
-    const validated = FilePathPattern.validate(FilePathPattern.format(pathSegments));
-    if (Either.isLeft(validated)) {
-        return null;
-    }
-    const restIndex = pathSegments.findIndex((seg) => seg._tag === "RestSegment");
-    if (restIndex !== -1 && restIndex !== pathSegments.length - 1) {
-        return null;
-    }
-    const routePathSegments = pathSegments.filter((seg) => seg._tag !== "GroupSegment");
-    const routePath = FilePathPattern.format(routePathSegments);
-    return {
-        handle,
-        modulePath: `/${path}`,
-        routePath,
-        segments: pathSegments,
-    };
-}
-function importModule(load) {
-    return Effect.tryPromise({
-        try: () => load(),
-        catch: (cause) => new FileRouterError({ reason: "Import", cause }),
-    });
-}
-export function layer(loadOrOptions) {
-    const options = typeof loadOrOptions === "function"
-        ? {
-            load: loadOrOptions,
-            path: NPath.join(NodeUtils.getEntrypoint(), "routes"),
-        }
-        : loadOrOptions;
-    let treePath = options.path;
-    if (treePath.startsWith("file://")) {
-        treePath = NUrl.fileURLToPath(treePath);
-    }
-    if (NPath.extname(treePath) === "") {
-        treePath = NPath.join(treePath, "server.gen.ts");
-    }
-    const routesPath = NPath.dirname(treePath);
-    const treeFilename = NPath.basename(treePath);
-    const relativeRoutesPath = NPath.relative(process.cwd(), routesPath);
-    return Layer.scoped(Route.Routes, Effect.gen(function* () {
-        // Generate routes file before loading
-        yield* FileRouterCodegen.update(routesPath, treeFilename);
-        // Load and build route tree
-        const m = yield* importModule(options.load);
-        const routeTree = yield* fromFileRoutes(m.default);
-        // Watch for changes (only when Development service is available)
-        yield* Function.pipe(Development.stream(), Stream.filter((e) => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)), Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)), Effect.fork);
-        return routeTree;
-    }));
-}
-export function fromFileRoutes(fileRoutes) {
-    return Effect.gen(function* () {
-        const mounts = {};
-        for (const [path, loaders] of Object.entries(fileRoutes)) {
-            const modules = yield* Effect.forEach(loaders, (loader) => Effect.promise(() => loader()));
-            const allRoutes = [];
-            for (const m of modules) {
-                if (Route.isRouteSet(m.default)) {
-                    for (const route of m.default) {
-                        ;
-                        allRoutes.push(route);
-                    }
-                }
-            }
-            mounts[path] = allRoutes;
-        }
-        return RouteTree.make(mounts);
-    });
-}
-export function walkRoutesDirectory(dir) {
-    return Effect.gen(function* () {
-        const fs = yield* FileSystem.FileSystem;
-        const files = yield* fs.readDirectory(dir, { recursive: true });
-        return yield* getFileRoutes(files);
-    });
-}
-export function getFileRoutes(paths) {
-    return Effect.gen(function* () {
-        const routes = paths
-            .map((f) => f.match(ROUTE_PATH_REGEX))
-            .filter(Boolean)
-            .map((v) => {
-            const path = v[0];
-            try {
-                return parseRoute(path);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((route) => route !== null)
-            .toSorted((a, b) => {
-            const aDepth = a.segments.length;
-            const bDepth = b.segments.length;
-            const aHasRest = a.segments.some((seg) => seg._tag === "RestSegment");
-            const bHasRest = b.segments.some((seg) => seg._tag === "RestSegment");
-            return (
-            // rest is a dominant factor (routes with rest come last)
-            (+aHasRest - +bHasRest) * 1000 +
-                // depth is reversed for rest
-                (aDepth - bDepth) * (1 - 2 * +aHasRest) +
-                // lexicographic comparison as tiebreaker
-                a.modulePath.localeCompare(b.modulePath) * 0.001);
-        });
-        // Detect conflicting routes at the same path
-        const routesByPath = new Map();
-        for (const route of routes) {
-            const existing = routesByPath.get(route.routePath) || [];
-            existing.push(route);
-            routesByPath.set(route.routePath, existing);
-        }
-        for (const [path, pathRoutes] of routesByPath) {
-            const routeHandles = pathRoutes.filter((h) => h.handle === "route");
-            if (routeHandles.length > 1) {
-                yield* new FileRouterError({ reason: "Conflict", path });
-            }
-        }
-        return routes;
-    });
-}

package/dist/FileRouterCodegen.d.ts

@@ -1,18 +0,0 @@
-import * as FileSystem from "./FileSystem.ts";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import * as FilePathPattern from "./FilePathPattern.ts";
-import * as FileRouter from "./FileRouter.ts";
-export declare function validateRouteModule(module: unknown): module is FileRouter.RouteModule;
-export declare function generatePathParamsSchema(segments: ReadonlyArray<FilePathPattern.Segment>): Schema.Struct<any> | null;
-/**
- * Validates all route modules in the given route handles.
- */
-export declare function validateRouteModules(path: string, routes: FileRouter.OrderedFileRoutes): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem>;
-export declare function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string | null;
-/**
- * Updates the tree file only if the generated content differs from the existing file.
- * This prevents infinite loops when watching for file changes.
- */
-export declare function update(routesPath: string, treePath?: string): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem>;
-export declare function dump(routesPath: string, treePath?: string): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem>;

package/dist/FileRouterCodegen.js

@@ -1,227 +0,0 @@
-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";
-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;
-}
-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;
-    }
-    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 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);
-    }
-    // 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 });
-    }
-    // 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 `/**
- * 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({
-            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}`);
-        }
-    });
-}
-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({
-            reason: "FileSystem",
-            cause,
-            path: treePath,
-        })));
-    });
-}

package/dist/FileRouterPattern.d.ts

@@ -1,9 +0,0 @@
-import * as RouterPattern from "./RouterPattern.ts";
-export type GroupSegment<Name extends string = string> = {
-    _tag: "GroupSegment";
-    name: Name;
-};
-export type Segment = RouterPattern.Segment | GroupSegment;
-export declare function parse(pattern: string): Segment[];
-export declare function formatSegment(seg: Segment): string;
-export declare function format(segments: Segment[]): `/${string}`;

package/dist/FileRouterPattern.js

@@ -1,35 +0,0 @@
-import * as RouterPattern from "./RouterPattern.js";
-export function parse(pattern) {
-    const trimmedPath = pattern.replace(/(^\/)|(\/$)/g, "");
-    if (trimmedPath === "") {
-        return [];
-    }
-    const segmentStrings = trimmedPath
-        .split("/")
-        .filter(s => s !== "");
-    if (segmentStrings.length === 0) {
-        return [];
-    }
-    const segments = segmentStrings.map((s) => {
-        // (group) - Groups (FileRouter-specific)
-        const groupMatch = s.match(/^\((\w+)\)$/);
-        if (groupMatch) {
-            return { _tag: "GroupSegment", name: groupMatch[1] };
-        }
-        // Delegate to RouterPattern for all other segment types
-        return RouterPattern.parseSegment(s);
-    });
-    if (segments.some((seg) => seg === null)) {
-        throw new Error(`Invalid path segment in "${pattern}": contains invalid characters or format`);
-    }
-    return segments;
-}
-export function formatSegment(seg) {
-    if (seg._tag === "GroupSegment")
-        return `(${seg.name})`;
-    return RouterPattern.formatSegment(seg);
-}
-export function format(segments) {
-    const joined = segments.map(formatSegment).join("/");
-    return (joined ? `/${joined}` : "/");
-}