polen 0.11.0-next.14 → 0.11.0-next.16

package/src/lib/mask/apply.ts

@@ -19,16 +19,16 @@ import type { GetDataType, Mask } from './mask.js'
  * - Non-objects throw an error at runtime
  */
 // dprint-ignore
-export type Apply<Data, M extends Mask> =
-    M extends { type: `binary`, show: boolean }
-      ? M[`show`] extends true
-        ? Data
+export type Apply<$Data, $M extends Mask> =
+    $M extends { type: `binary`, show: boolean }
+      ? $M[`show`] extends true
+        ? $Data
         : undefined
-      : M extends { type: `properties`, mode: string, properties: any[] }
-        ? Data extends object
-          ? M[`mode`] extends `allow`
-            ? Pick<Data, Extract<M[`properties`][number], keyof Data>>
-            : Omit<Data, Extract<M[`properties`][number], keyof Data>>
+      : $M extends { type: `properties`, mode: string, properties: any[] }
+        ? $Data extends object
+          ? $M[`mode`] extends `allow`
+            ? Pick<$Data, Extract<$M[`properties`][number], keyof $Data>>
+            : Omit<$Data, Extract<$M[`properties`][number], keyof $Data>>
           : never  // Non-objects not allowed with property masks
         : never
 

package/src/lib/mask/mask.test-d.ts

@@ -7,7 +7,7 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.js'
   type Options = InferOptions<unknown>
 
   // This is a type-level assertion - we need to use a different pattern
-  type _Test = Ts.AssertEqual<Options, boolean | string[] | Record<string, boolean>>
+  type _Test = Ts.AssertExact<Options, boolean | string[] | Record<string, boolean>>
 
   // All of these should be valid options
   const option1: Options = true

package/src/lib/memory-filesystem/$$.ts

@@ -0,0 +1 @@
+export * from './memory-filesystem.js'

package/src/lib/memory-filesystem/$.ts

@@ -0,0 +1 @@
+export * as MemoryFilesystem from './$$.js'

package/src/lib/memory-filesystem/memory-filesystem.ts

@@ -0,0 +1,162 @@
+import { SystemError } from '@effect/platform/Error'
+import { FileSystem } from '@effect/platform/FileSystem'
+import { Effect, Layer } from 'effect'
+
+// ============================================================================
+// Error Factories
+// ============================================================================
+
+const createUnsupportedError = (method: string, operation: string) =>
+  new SystemError({
+    reason: 'PermissionDenied',
+    module: 'FileSystem',
+    method,
+    description: `${operation} not supported in memory filesystem`,
+  })
+
+const createNotFoundError = (method: string, path: string, operation: string) =>
+  new SystemError({
+    reason: 'NotFound',
+    module: 'FileSystem',
+    method,
+    pathOrDescriptor: path,
+    description: `ENOENT: no such file or directory, ${operation} '${path}'`,
+  })
+
+// Convenience factories for common patterns
+const failUnsupported = (method: string, operation: string) => Effect.fail(createUnsupportedError(method, operation))
+
+const failNotFound = (method: string, path: string, operation: string) =>
+  Effect.fail(createNotFoundError(method, path, operation))
+
+// ============================================================================
+// Memory Filesystem Types
+// ============================================================================
+
+/**
+ * Memory filesystem disk layout specification.
+ * Keys are file paths, values are file contents as strings.
+ */
+export interface DiskLayout {
+  readonly [path: string]: string
+}
+
+// ============================================================================
+// Memory Filesystem Layer Factory
+// ============================================================================
+
+/**
+ * Creates a memory filesystem layer from a disk layout specification.
+ * This layer can be composed with other layers for testing.
+ *
+ * @param diskLayout - Object mapping file paths to their contents
+ * @returns Layer that provides a FileSystem service backed by memory
+ */
+export const layer = (diskLayout: DiskLayout) =>
+  Layer.succeed(
+    FileSystem,
+    {
+      // File existence check
+      exists: (path: string) => Effect.succeed(path in diskLayout),
+
+      // Read file as string
+      readFileString: (path: string) => {
+        const content = diskLayout[path]
+        return content !== undefined
+          ? Effect.succeed(content)
+          : failNotFound('readFileString', path, 'open')
+      },
+
+      // Read directory contents
+      readDirectory: (path: string) => {
+        const normalizedPath = path.endsWith('/') ? path : path + '/'
+        const entries = Object.keys(diskLayout)
+          .filter(filePath => filePath.startsWith(normalizedPath))
+          .map(filePath => filePath.slice(normalizedPath.length))
+          .filter(relativePath => relativePath.length > 0 && !relativePath.includes('/'))
+
+        return entries.length > 0
+          ? Effect.succeed(entries)
+          : failNotFound('readDirectory', path, 'scandir')
+      },
+
+      // File stats (simplified - just checks existence)
+      stat: (path: string) => {
+        if (path in diskLayout) {
+          return Effect.succeed({
+            isFile: () => true,
+            isDirectory: () => false,
+            isSymbolicLink: () => false,
+            size: diskLayout[path]!.length,
+          } as any)
+        }
+
+        // Check if it's a directory (has files under it)
+        const normalizedPath = path.endsWith('/') ? path : path + '/'
+        const hasChildren = Object.keys(diskLayout).some(filePath =>
+          filePath.startsWith(normalizedPath) && filePath !== path
+        )
+
+        if (hasChildren) {
+          return Effect.succeed({
+            isFile: () => false,
+            isDirectory: () => true,
+            isSymbolicLink: () => false,
+            size: 0,
+          } as any)
+        }
+
+        return failNotFound('stat', path, 'stat')
+      },
+
+      // Stub implementations for write operations (not needed for read-only testing)
+      writeFileString: () => failUnsupported('writeFileString', 'Write operations'),
+      writeFile: () => failUnsupported('writeFile', 'Write operations'),
+      truncate: () => failUnsupported('truncate', 'Write operations'),
+      remove: () => failUnsupported('remove', 'Write operations'),
+      makeDirectory: () => failUnsupported('makeDirectory', 'Write operations'),
+      makeTempDirectory: () => failUnsupported('makeTempDirectory', 'Write operations'),
+      makeTempDirectoryScoped: () => failUnsupported('makeTempDirectoryScoped', 'Write operations'),
+      makeTempFile: () => failUnsupported('makeTempFile', 'Write operations'),
+      makeTempFileScoped: () => failUnsupported('makeTempFileScoped', 'Write operations'),
+      open: () => failUnsupported('open', 'File operations'),
+      copy: () => failUnsupported('copy', 'Write operations'),
+      copyFile: () => failUnsupported('copyFile', 'Write operations'),
+      chmod: () => failUnsupported('chmod', 'Write operations'),
+      chown: () => failUnsupported('chown', 'Write operations'),
+      access: (path: string) =>
+        path in diskLayout
+          ? Effect.void
+          : failNotFound('access', path, 'access'),
+      link: () => failUnsupported('link', 'Write operations'),
+      realPath: (path: string) => Effect.succeed(path),
+      readFile: (path: string) => {
+        const content = diskLayout[path]
+        return content !== undefined
+          ? Effect.succeed(new TextEncoder().encode(content))
+          : failNotFound('readFile', path, 'open')
+      },
+      readLink: () => failUnsupported('readLink', 'Symlink operations'),
+      symlink: () => failUnsupported('symlink', 'Write operations'),
+      utimes: () => failUnsupported('utimes', 'Write operations'),
+      watch: () => failUnsupported('watch', 'Watch operations'),
+
+      // Rename/move files (not implemented for memory filesystem)
+      rename: () => failUnsupported('rename', 'Write operations'),
+
+      // Create writable sink (not implemented for memory filesystem)
+      sink: () => failUnsupported('sink', 'Stream operations'),
+
+      // Create readable stream (not implemented for memory filesystem)
+      stream: () => failUnsupported('stream', 'Stream operations'),
+    },
+  )
+
+/**
+ * Convenience function for creating memory filesystem layers from disk layout.
+ * This matches the API used in schema tests.
+ *
+ * @param diskLayout - Object mapping file paths to their contents
+ * @returns Layer that provides an Effect Platform FileSystem service backed by memory
+ */
+export const layerFromDiskLayout = (diskLayout: DiskLayout) => layer(diskLayout)

package/src/lib/path-map/path-map.ts

@@ -15,52 +15,52 @@ export interface PathInput {
 /**
  * Processed paths with $ properties added to directories
  */
-export type ProcessedPaths<T> =
+export type ProcessedPaths<$T> =
   & {
-    [K in keyof T]: T[K] extends string ? string
-      : ProcessedPaths<T[K]> & { [DIR_KEY]: string }
+    [K in keyof $T]: $T[K] extends string ? string
+      : ProcessedPaths<$T[K]> & { [DIR_KEY]: string }
   }
-  & (T extends PathInput ? { [DIR_KEY]: string } : {})
+  & ($T extends PathInput ? { [DIR_KEY]: string } : {})
 
 /**
  * Path map containing only relative paths
  */
-export type RelativePathMap<T extends PathInput = PathInput> = ProcessedPaths<T>
+export type RelativePathMap<$T extends PathInput = PathInput> = ProcessedPaths<$T>
 
 /**
  * Path map containing paths rooted at the PathMap's origin
  */
-export type RootedPathMap<T extends PathInput = PathInput> = ProcessedPaths<T>
+export type RootedPathMap<$T extends PathInput = PathInput> = ProcessedPaths<$T>
 
 /**
  * Path map containing absolute paths
  */
-export type AbsolutePathMap<T extends PathInput = PathInput> = ProcessedPaths<T>
+export type AbsolutePathMap<$T extends PathInput = PathInput> = ProcessedPaths<$T>
 
 /**
  * Combined path map with relative, rooted, and absolute variants
  */
-export interface PathMap<T extends PathInput = PathInput> {
+export interface PathMap<$T extends PathInput = PathInput> {
   /**
    * Paths relative to their parent directory
    * @example
    * paths.relative.template.server.app // 'app.ts'
    */
-  relative: RelativePathMap<T>
+  relative: RelativePathMap<$T>
 
   /**
    * Paths from the PathMap's root
    * @example
    * paths.rooted.template.server.app // 'template/server/app.ts'
    */
-  rooted: RootedPathMap<T>
+  rooted: RootedPathMap<$T>
 
   /**
    * Absolute paths from the filesystem root
    * @example
    * paths.absolute.template.server.app // '/project/template/server/app.ts'
    */
-  absolute: AbsolutePathMap<T>
+  absolute: AbsolutePathMap<$T>
 
   /**
    * The base path used for absolute paths
@@ -143,13 +143,13 @@ export function create<T extends PathInput>(paths: T, base?: string): RelativePa
  * prod.absolute.src.lib.utils // '/prod/src/lib/utils.ts'
  * ```
  */
-export const rebase = <T extends PathInput>(
-  pathMap: PathMap<T> | RelativePathMap<T>,
+export const rebase = <$T extends PathInput>(
+  pathMap: PathMap<$T> | RelativePathMap<$T>,
   base: string,
-): PathMap<T> => {
+): PathMap<$T> => {
   // Extract the input structure from the relative paths
   const input = extractInput(pathMap)
-  return create(input, base) as PathMap<T>
+  return create(input, base) as PathMap<$T>
 }
 
 // Helper to process paths for relative variant (local to parent)

package/src/lib/react-router-effect/$$.ts

@@ -0,0 +1,5 @@
+// export * from './create-loader.js'
+export * from './route-helpers.js'
+export * from './route.js'
+export * from './types.js'
+export * from './use-loader-data.js'

package/src/lib/react-router-effect/$.ts

@@ -0,0 +1 @@
+export * as ReactRouterEffect from './$$.js'

package/src/lib/react-router-effect/README.md

@@ -0,0 +1,178 @@
+# React Router Effect
+
+Automatic codec support for React Router using Effect schemas.
+
+## Overview
+
+This library provides seamless integration between React Router's data loading system and Effect's schema system. It enables:
+
+- **Automatic encoding/decoding** of loader data using Effect schemas
+- **Type-safe data access** in components
+- **Flexible data retrieval** from any route in the hierarchy
+- **Zero manual serialization** - never see encoded forms in your app code
+
+## Quick Start
+
+```typescript
+import {
+  schemaRoute,
+  useLoaderData,
+} from '#lib/react-router-effect/react-router-effect'
+import { CatalogSchema } from './schemas'
+
+// Define a route with a schema
+export const catalogRoute = schemaRoute({
+  path: '/catalog/:id',
+  schema: CatalogSchema,
+  loader: async ({ params }) => {
+    const catalog = await fetchCatalog(params.id)
+    return catalog // Automatically encoded using the schema
+  },
+  Component: CatalogView,
+})
+
+// Access decoded data in your component
+function CatalogView() {
+  const catalog = useLoaderData(CatalogSchema) // Automatically decoded!
+  return <h1>{catalog.name}</h1>
+}
+```
+
+## Core Concepts
+
+### Schema Attachment
+
+Routes can have Effect schemas attached via the `handle` property:
+
+```typescript
+const route = schemaRoute({
+  schema: MySchema,
+  // ... other route config
+})
+```
+
+### Automatic Codec
+
+- **In loaders**: Return decoded data - it's automatically encoded for transport
+- **In components**: Receive decoded data - encoding/decoding is transparent
+
+### Flexible Data Access
+
+```typescript
+// Get current route's data
+const data = useLoaderData(CurrentSchema)
+
+// Get ancestor route's data
+const parentData = useLoaderData(ParentSchema)
+
+// Get data by route ID (requires type augmentation)
+const specificData = useRouteDataById('routeId')
+
+// Get all route data at once
+const allData = useRouteData()
+```
+
+## API Reference
+
+### `schemaRoute(config)`
+
+Creates a route with an attached Effect schema.
+
+```typescript
+const route = schemaRoute({
+  id: 'my-route',
+  path: '/path',
+  schema: MySchema,
+  loader: async (args) => data,
+  Component: MyComponent,
+})
+```
+
+### `useLoaderData(schema)`
+
+Retrieves and decodes data from any route with the matching schema.
+
+```typescript
+const data = useLoaderData(MySchema)
+```
+
+### `useRouteDataById(routeId)`
+
+Type-safe data access by route ID (requires registry augmentation).
+
+```typescript
+// First, augment the registry
+declare module '#lib/react-router-effect/types' {
+  interface RouteSchemaRegistry {
+    'my-route': typeof MySchema
+  }
+}
+
+// Then use type-safe access
+const data = useRouteDataById('my-route')
+```
+
+### `useRouteData()`
+
+Returns all route data from the current hierarchy, decoded.
+
+```typescript
+const allData = useRouteData()
+// Access: allData.routeId
+```
+
+### `createEffectLoader(schema, loader)`
+
+Lower-level API for creating loaders with automatic encoding.
+
+```typescript
+const loader = createEffectLoader(MySchema, async ({ params }) => {
+  return await fetchData(params.id)
+})
+```
+
+## Migration from superjson
+
+Before:
+
+```typescript
+const loader = createLoader(async ({ params }) => {
+  const data = await fetchData(params.id)
+  return superjson.stringify(data)
+})
+
+// In component
+const encodedData = useLoaderData()
+const data = superjson.parse(encodedData)
+```
+
+After:
+
+```typescript
+const route = schemaRoute({
+  schema: DataSchema,
+  loader: async ({ params }) => {
+    return await fetchData(params.id) // No manual encoding!
+  },
+})
+
+// In component
+const data = useLoaderData(DataSchema) // Already decoded!
+```
+
+## Type Safety
+
+The library provides full TypeScript inference:
+
+- Route parameters are typed based on path
+- Loader data is typed based on schema
+- Components receive correctly typed props
+- Route IDs can be made type-safe via registry
+
+## Benefits
+
+1. **Decentralized** - Each route owns its schema
+2. **Transparent** - Encoding/decoding happens automatically
+3. **Type-safe** - Full TypeScript support
+4. **Flexible** - Access data from any route
+5. **Compatible** - Works alongside existing React Router code

package/src/lib/react-router-effect/create-loader.ts

@@ -0,0 +1,57 @@
+// import { Effect, Schema } from 'effect'
+// import type { LoaderFunction } from 'react-router'
+
+// /**
+//  * Creates a React Router loader from a function that returns an Effect.
+//  * The Effect will be run and the result will be encoded using the provided schema.
+//  *
+//  * @example
+//  * ```typescript
+//  * const loader = createEffectLoaderFromEffect(
+//  *   UserSchema,
+//  *   ({ params }) => Effect.gen(function* () {
+//  *     const service = yield* UserService
+//  *     return yield* service.getUser(params.id)
+//  *   })
+//  * )
+//  * ```
+//  */
+// export const createEffectLoaderFromEffect = <TSchema extends Schema.Schema.Any = Schema.Schema.Any>(
+//   schema: TSchema,
+//   loader: (args: Parameters<LoaderFunction>[0]) => Effect.Effect<Schema.Schema.Type<TSchema>, any, any>,
+// ): LoaderFunction => {
+//   return async (args) => {
+//     const decodedData = await Effect.runPromise(loader(args))
+//     const encodedData = Schema.encodeSync(schema as any)(decodedData as any)
+//     return encodedData
+//   }
+// }
+
+// /**
+//  * Creates a loader function that automatically encodes the returned data using an Effect schema.
+//  * This ensures that complex types (Date, BigInt, custom classes) are properly serialized
+//  * for transport between server and client.
+//  *
+//  * @example
+//  * ```typescript
+//  * export const loader = createEffectLoader(
+//  *   UserSchema,
+//  *   async ({ params }) => {
+//  *     const user = await fetchUser(params.id)
+//  *     return user // Will be automatically encoded
+//  *   }
+//  * )
+//  * ```
+//  */
+// export const createEffectLoaderFromPromise = <TSchema extends Schema.Schema.Any = Schema.Schema.Any>(
+//   schema: TSchema,
+//   loader: (args: Parameters<LoaderFunction>[0]) => Promise<Schema.Schema.Type<TSchema>>,
+// ): LoaderFunction => {
+//   return async (args) => {
+//     // Convert Promise to Effect for internal consistency
+//     const loaderEffect = Effect.tryPromise(() => loader(args))
+//     const decodedData = await Effect.runPromise(loaderEffect)
+//     const encodedData = Schema.encodeSync(schema as any)(decodedData as any)
+//     return encodedData
+//   }
+// }

package/src/lib/react-router-effect/route-helpers.ts

@@ -0,0 +1,88 @@
+import type { ReactRouter } from '#dep/react-router/index'
+import type { React } from '#dep/react/index'
+import { Effect, Schema } from 'effect'
+import type { IsNever } from 'type-fest'
+import type { SchemaRoute, SchemaRouteConfig } from './types.js'
+
+export type RouteObjectIndexInput = RouteObjectIndexInputConfig | React.ComponentType
+export type RouteObjectIndexInputConfig = Omit<ReactRouter.IndexRouteObject, 'index' | 'children'>
+
+export type SchemaRouteIndexConfig<TSchema extends Schema.Schema.Any> =
+  & Omit<SchemaRouteConfig<TSchema>, 'index' | 'children' | 'path'>
+  & {
+    index?: true
+  }
+
+/**
+ * Helper to create an index route configuration with optional schema support
+ * @param input - Either a component or a route configuration object (optionally with schema)
+ * @returns An index route object
+ */
+export function routeIndex<TSchema extends Schema.Schema.Any = never>(
+  input: IsNever<TSchema> extends true ? RouteObjectIndexInput
+    : SchemaRouteIndexConfig<TSchema> | React.ComponentType,
+): TSchema extends never ? ReactRouter.IndexRouteObject : SchemaRoute<TSchema> {
+  const routeConfig: any = isComponentType(input) ? { Component: input } : input
+  const { schema, loader, handle, ...restConfig } = routeConfig
+
+  // Determine route ID for index routes
+  let routeId: string | undefined = undefined
+  if (typeof restConfig.id === 'string') {
+    routeId = restConfig.id
+  } else if (restConfig.id === true) {
+    routeId = '@index'
+  }
+
+  // If no schema provided, return a regular index route
+  if (!schema) {
+    return {
+      ...restConfig,
+      ...(routeId && { id: routeId }),
+      handle,
+      loader,
+      index: true,
+      children: undefined,
+    } as any
+  }
+
+  // Schema provided - add schema handling
+  const route: any = {
+    ...restConfig,
+    ...(routeId && { id: routeId }),
+    index: true,
+    children: undefined,
+    handle: {
+      ...handle,
+      schema,
+      schemaId: routeId,
+    },
+  }
+
+  if (loader) {
+    route.loader = async (args: any) => {
+      // Call the loader function
+      const result = loader(args)
+
+      // Check if result is an Effect or a Promise
+      let decodedData: any
+      if (Effect.isEffect(result)) {
+        // It's an Effect, run it
+        decodedData = await Effect.runPromise(result as any)
+      } else {
+        // It's a Promise, await it
+        decodedData = await result
+      }
+
+      // Encode the data for transport using the schema
+      const encodedData = Schema.encodeSync(schema as any)(decodedData as any)
+
+      return encodedData
+    }
+  }
+
+  return route as any
+}
+
+const isComponentType = (value: unknown): value is React.ComponentType => {
+  return typeof value === 'function'
+}