effect-start 0.20.0 → 0.21.0

package/src/FileSystem.ts

@@ -0,0 +1,403 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Brand from "effect/Brand"
+import * as Channel from "effect/Channel"
+import * as Chunk from "effect/Chunk"
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Option from "effect/Option"
+import * as Sink from "effect/Sink"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import * as PlatformError from "./PlatformError.ts"
+
+export interface FileSystem {
+  readonly access: (
+    path: string,
+    options?: AccessFileOptions,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly copy: (
+    fromPath: string,
+    toPath: string,
+    options?: CopyOptions,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly copyFile: (
+    fromPath: string,
+    toPath: string,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly chmod: (
+    path: string,
+    mode: number,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly chown: (
+    path: string,
+    uid: number,
+    gid: number,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly exists: (
+    path: string,
+  ) => Effect.Effect<boolean, PlatformError.PlatformError>
+  readonly link: (
+    fromPath: string,
+    toPath: string,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly makeDirectory: (
+    path: string,
+    options?: MakeDirectoryOptions,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly makeTempDirectory: (
+    options?: MakeTempDirectoryOptions,
+  ) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly makeTempDirectoryScoped: (
+    options?: MakeTempDirectoryOptions,
+  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  readonly makeTempFile: (
+    options?: MakeTempFileOptions,
+  ) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly makeTempFileScoped: (
+    options?: MakeTempFileOptions,
+  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  readonly open: (
+    path: string,
+    options?: OpenFileOptions,
+  ) => Effect.Effect<File, PlatformError.PlatformError, Scope.Scope>
+  readonly readDirectory: (
+    path: string,
+    options?: ReadDirectoryOptions,
+  ) => Effect.Effect<Array<string>, PlatformError.PlatformError>
+  readonly readFile: (
+    path: string,
+  ) => Effect.Effect<Uint8Array, PlatformError.PlatformError>
+  readonly readFileString: (
+    path: string,
+    encoding?: string,
+  ) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly readLink: (
+    path: string,
+  ) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly realPath: (
+    path: string,
+  ) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly remove: (
+    path: string,
+    options?: RemoveOptions,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly rename: (
+    oldPath: string,
+    newPath: string,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly sink: (
+    path: string,
+    options?: SinkOptions,
+  ) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
+  readonly stat: (
+    path: string,
+  ) => Effect.Effect<File.Info, PlatformError.PlatformError>
+  readonly stream: (
+    path: string,
+    options?: StreamOptions,
+  ) => Stream.Stream<Uint8Array, PlatformError.PlatformError>
+  readonly symlink: (
+    fromPath: string,
+    toPath: string,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly truncate: (
+    path: string,
+    length?: SizeInput,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly utimes: (
+    path: string,
+    atime: Date | number,
+    mtime: Date | number,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly watch: (
+    path: string,
+    options?: WatchOptions,
+  ) => Stream.Stream<WatchEvent, PlatformError.PlatformError>
+  readonly writeFile: (
+    path: string,
+    data: Uint8Array,
+    options?: WriteFileOptions,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly writeFileString: (
+    path: string,
+    data: string,
+    options?: WriteFileStringOptions,
+  ) => Effect.Effect<void, PlatformError.PlatformError>
+}
+
+export const FileSystem: Context.Tag<FileSystem, FileSystem> = Context.GenericTag<FileSystem>(
+  "@effect/platform/FileSystem",
+)
+
+export type Size = Brand.Branded<bigint, "Size">
+
+export type SizeInput = bigint | number | Size
+
+export const Size = (bytes: SizeInput): Size =>
+  typeof bytes === "bigint" ? bytes as Size : BigInt(bytes) as Size
+
+export type OpenFlag =
+  | "r"
+  | "r+"
+  | "w"
+  | "wx"
+  | "w+"
+  | "wx+"
+  | "a"
+  | "ax"
+  | "a+"
+  | "ax+"
+
+export type SeekMode = "start" | "current"
+
+export interface AccessFileOptions {
+  readonly ok?: boolean
+  readonly readable?: boolean
+  readonly writable?: boolean
+}
+
+export interface MakeDirectoryOptions {
+  readonly recursive?: boolean
+  readonly mode?: number
+}
+
+export interface CopyOptions {
+  readonly overwrite?: boolean
+  readonly preserveTimestamps?: boolean
+}
+
+export interface MakeTempDirectoryOptions {
+  readonly directory?: string
+  readonly prefix?: string
+}
+
+export interface MakeTempFileOptions {
+  readonly directory?: string
+  readonly prefix?: string
+  readonly suffix?: string
+}
+
+export interface OpenFileOptions {
+  readonly flag?: OpenFlag
+  readonly mode?: number
+}
+
+export interface ReadDirectoryOptions {
+  readonly recursive?: boolean
+}
+
+export interface RemoveOptions {
+  readonly recursive?: boolean
+  readonly force?: boolean
+}
+
+export interface SinkOptions extends OpenFileOptions {}
+
+export interface StreamOptions {
+  readonly bufferSize?: number
+  readonly bytesToRead?: SizeInput
+  readonly chunkSize?: SizeInput
+  readonly offset?: SizeInput
+}
+
+export interface WriteFileOptions {
+  readonly flag?: OpenFlag
+  readonly mode?: number
+}
+
+export interface WriteFileStringOptions {
+  readonly flag?: OpenFlag
+  readonly mode?: number
+}
+
+export interface WatchOptions {
+  readonly recursive?: boolean
+}
+
+export const FileTypeId: unique symbol = Symbol.for("@effect/platform/FileSystem/File")
+
+export type FileTypeId = typeof FileTypeId
+
+export interface File {
+  readonly [FileTypeId]: FileTypeId
+  readonly fd: File.Descriptor
+  readonly stat: Effect.Effect<File.Info, PlatformError.PlatformError>
+  readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
+  readonly sync: Effect.Effect<void, PlatformError.PlatformError>
+  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
+  readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>
+  readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
+  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>
+}
+
+export declare namespace File {
+  export type Descriptor = Brand.Branded<number, "FileDescriptor">
+
+  export type Type =
+    | "File"
+    | "Directory"
+    | "SymbolicLink"
+    | "BlockDevice"
+    | "CharacterDevice"
+    | "FIFO"
+    | "Socket"
+    | "Unknown"
+
+  export interface Info {
+    readonly type: Type
+    readonly mtime: Option.Option<Date>
+    readonly atime: Option.Option<Date>
+    readonly birthtime: Option.Option<Date>
+    readonly dev: number
+    readonly ino: Option.Option<number>
+    readonly mode: number
+    readonly nlink: Option.Option<number>
+    readonly uid: Option.Option<number>
+    readonly gid: Option.Option<number>
+    readonly rdev: Option.Option<number>
+    readonly size: Size
+    readonly blksize: Option.Option<Size>
+    readonly blocks: Option.Option<number>
+  }
+}
+
+export const FileDescriptor = Brand.nominal<File.Descriptor>()
+
+export type WatchEvent = WatchEvent.Create | WatchEvent.Update | WatchEvent.Remove
+
+export declare namespace WatchEvent {
+  export interface Create {
+    readonly _tag: "Create"
+    readonly path: string
+  }
+
+  export interface Update {
+    readonly _tag: "Update"
+    readonly path: string
+  }
+
+  export interface Remove {
+    readonly _tag: "Remove"
+    readonly path: string
+  }
+}
+
+export const WatchEventCreate: Data.Case.Constructor<WatchEvent.Create, "_tag"> = Data.tagged<WatchEvent.Create>(
+  "Create",
+)
+
+export const WatchEventUpdate: Data.Case.Constructor<WatchEvent.Update, "_tag"> = Data.tagged<WatchEvent.Update>(
+  "Update",
+)
+
+export const WatchEventRemove: Data.Case.Constructor<WatchEvent.Remove, "_tag"> = Data.tagged<WatchEvent.Remove>(
+  "Remove",
+)
+
+export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")<
+  WatchBackend,
+  {
+    readonly register: (
+      path: string,
+      stat: File.Info,
+      options?: WatchOptions,
+    ) => Option.Option<Stream.Stream<WatchEvent, PlatformError.PlatformError>>
+  }
+>() {}
+
+export const make = (
+  impl: Omit<FileSystem, "exists" | "readFileString" | "stream" | "sink" | "writeFileString">,
+): FileSystem => {
+  return FileSystem.of({
+    ...impl,
+    exists: (path) =>
+      Function.pipe(
+        impl.access(path),
+        Effect.as(true),
+        Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e)),
+      ),
+    readFileString: (path, encoding) =>
+      Effect.tryMap(impl.readFile(path), {
+        try: (_) => new TextDecoder(encoding).decode(_),
+        catch: (cause) =>
+          new PlatformError.BadArgument({
+            module: "FileSystem",
+            method: "readFileString",
+            description: "invalid encoding",
+            cause,
+          }),
+      }),
+    stream: (path, options) =>
+      Function.pipe(
+        impl.open(path, { flag: "r" }),
+        options?.offset
+          ? Effect.tap((file) => file.seek(options.offset!, "start"))
+          : Function.identity,
+        Effect.map((file) => fileStream(file, options)),
+        Stream.unwrapScoped,
+      ),
+    sink: (path, options) =>
+      Function.pipe(
+        impl.open(path, { flag: "w", ...options }),
+        Effect.map((file) => Sink.forEach((_: Uint8Array) => file.writeAll(_))),
+        Sink.unwrapScoped,
+      ),
+    writeFileString: (path, data, options) =>
+      Effect.flatMap(
+        Effect.try({
+          try: () => new TextEncoder().encode(data),
+          catch: (cause) =>
+            new PlatformError.BadArgument({
+              module: "FileSystem",
+              method: "writeFileString",
+              description: "could not encode string",
+              cause,
+            }),
+        }),
+        (_) => impl.writeFile(path, _, options),
+      ),
+  })
+}
+
+const fileStream = (file: File, {
+  bufferSize = 16,
+  bytesToRead: bytesToRead_,
+  chunkSize: chunkSize_ = Size(64 * 1024),
+}: StreamOptions = {}) => {
+  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
+  const chunkSize = Size(chunkSize_)
+
+  function loop(
+    totalBytesRead: bigint,
+  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, PlatformError.PlatformError, unknown, void, unknown> {
+    if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
+      return Channel.void
+    }
+
+    const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
+      ? bytesToRead - totalBytesRead
+      : chunkSize
+
+    return Channel.flatMap(
+      file.readAlloc(toRead),
+      Option.match({
+        onNone: () => Channel.void,
+        onSome: (buf) =>
+          Channel.flatMap(
+            Channel.write(Chunk.of(buf)),
+            () => loop(totalBytesRead + BigInt(buf.length)),
+          ),
+      }),
+    )
+  }
+
+  return Stream.bufferChunks(
+    Stream.fromChannel(loop(BigInt(0))),
+    { capacity: bufferSize },
+  )
+}

package/src/PlatformError.ts

@@ -7,9 +7,9 @@ import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import type * as Types from "effect/Types"
 
-import { TypeId as TypeId_ } from "@effect/platform/Error"
-
-export const TypeId: typeof TypeId_ = TypeId_
+export const TypeId: unique symbol = Symbol.for(
+  "@effect/platform/Error/PlatformError",
+)
 
 export type TypeId = typeof TypeId
 

package/src/Socket.ts

@@ -0,0 +1,48 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Predicate from "effect/Predicate"
+import * as PlatformError from "./PlatformError.ts"
+
+export const SocketErrorTypeId: unique symbol = Symbol.for("@effect/platform/Socket/SocketError")
+
+export type SocketErrorTypeId = typeof SocketErrorTypeId
+
+export const isSocketError = (u: unknown): u is SocketError =>
+  Predicate.hasProperty(u, SocketErrorTypeId)
+
+export type SocketError = SocketGenericError | SocketCloseError
+
+export class SocketGenericError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError")<{
+  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout"
+  readonly cause: unknown
+}> {
+  get message() {
+    return `An error occurred during ${this.reason}`
+  }
+}
+
+export class SocketCloseError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError")<{
+  readonly reason: "Close"
+  readonly code: number
+  readonly closeReason?: string | undefined
+}> {
+  static is(u: unknown): u is SocketCloseError {
+    return isSocketError(u) && u.reason === "Close"
+  }
+
+  static isClean(isClean: (code: number) => boolean) {
+    return function(u: unknown): u is SocketCloseError {
+      return SocketCloseError.is(u) && isClean(u.code)
+    }
+  }
+
+  get message() {
+    if (this.closeReason) {
+      return `${this.reason}: ${this.code}: ${this.closeReason}`
+    }
+    return `${this.reason}: ${this.code}`
+  }
+}
+
+export const defaultCloseCodeIsError = (code: number) => code !== 1000 && code !== 1006

package/src/Start.ts

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem"
+import * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
@@ -84,7 +84,6 @@ export function serve<
     BunServer.withLogAddress,
     Layer.provide(appLayer),
     Layer.provide(NodeFileSystem.layer),
-    Layer.provide(BunServer.layer()),
   ) as Layer.Layer<BunServer.BunServer, never, never>
 
   return Function.pipe(

package/src/bun/BunServer.ts

@@ -1,4 +1,4 @@
-import * as Socket from "@effect/platform/Socket"
+import * as Socket from "../Socket.ts"
 import * as Bun from "bun"
 import * as Config from "effect/Config"
 import * as Context from "effect/Context"
@@ -9,6 +9,7 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 import type * as Scope from "effect/Scope"
+import * as NOs from "node:os"
 import * as PathPattern from "../PathPattern.ts"
 import * as PlataformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
@@ -16,11 +17,16 @@ import * as RouteHttp from "../RouteHttp.ts"
 import * as RouteMount from "../RouteMount.ts"
 import * as RouteTree from "../RouteTree.ts"
 import * as BunRoute from "./BunRoute.ts"
-import * as BunServerRequest from "./BunServerRequest.ts"
+export interface WebSocketContext {
+  readonly deferred: Deferred.Deferred<Bun.ServerWebSocket<WebSocketContext>>
+  readonly closeDeferred: Deferred.Deferred<void, Socket.SocketError>
+  readonly buffer: Array<Uint8Array | string>
+  run: (_: Uint8Array | string) => void
+}
 
 type FetchHandler = (
   request: Request,
-  server: Bun.Server<BunServerRequest.WebSocketContext>,
+  server: Bun.Server<WebSocketContext>,
 ) => Response | Promise<Response>
 
 /**
@@ -38,7 +44,7 @@ interface BunServeOptions {
 }
 
 export type BunServer = {
-  readonly server: Bun.Server<BunServerRequest.WebSocketContext>
+  readonly server: Bun.Server<WebSocketContext>
   readonly pushHandler: (fetch: FetchHandler) => void
   readonly popHandler: () => void
 }
@@ -66,8 +72,10 @@ export const make = (
           : Effect.succeed(3000)
       }),
     )
+    const hostFlag = process.argv.includes("--host")
     const hostname = yield* Config.string("HOSTNAME").pipe(
-      Effect.catchTag("ConfigError", () => Effect.succeed(undefined)),
+      Effect.catchTag("ConfigError", () =>
+        Effect.succeed(hostFlag ? "0.0.0.0" : undefined)),
     )
 
     const handlerStack: Array<FetchHandler> = [
@@ -76,35 +84,43 @@ export const make = (
       },
     ]
 
-    const service = BunServer.of({
-      // During the construction we need to create a service imlpementation
-      // first so we can provide it in the runtime that will be used in web
-      // handlers. After we create the runtime, we set it below so it's always
-      // available at runtime.
-      // An alternative approach would be to use Bun.Server.reload but I prefer
-      // to avoid it since it's badly documented and has bunch of bugs.
-      server: undefined as any,
-      pushHandler(fetch) {
-        handlerStack.push(fetch)
-        reload()
-      },
-      popHandler() {
-        handlerStack.pop()
-        reload()
-      },
-    })
+    const service = BunServer
+      .of({
+        // During the construction we need to create a service imlpementation
+        // first so we can provide it in the runtime that will be used in web
+        // handlers. After we create the runtime, we set it below so it's always
+        // available at runtime.
+        // An alternative approach would be to use Bun.Server.reload but I prefer
+        // to avoid it since it's badly documented and has bunch of bugs.
+        server: undefined as any,
+        pushHandler(fetch) {
+          handlerStack
+            .push(fetch)
+          reload()
+        },
+        popHandler() {
+          handlerStack
+            .pop()
+          reload()
+        },
+      })
 
-    const runtime = yield* Effect.runtime().pipe(
-      Effect.andThen(Runtime.provideService(BunServer, service)),
-    )
+    const runtime = yield* Effect
+      .runtime()
+      .pipe(
+        Effect
+          .andThen(Runtime
+            .provideService(BunServer, service)),
+      )
 
     let currentRoutes: BunRoute.BunRoutes = routes
       ? yield* walkBunRoutes(runtime, routes)
       : {}
 
-    const websocket: Bun.WebSocketHandler<BunServerRequest.WebSocketContext> = {
+    const websocket: Bun.WebSocketHandler<WebSocketContext> = {
       open(ws) {
-        Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws))
+        Deferred
+          .unsafeDone(ws.data.deferred, Exit.succeed(ws))
       },
       message(ws, message) {
         ws.data.run(message)
@@ -183,11 +199,14 @@ export const withLogAddress = <A, E, R>(
   Layer
     .effectDiscard(
       BunServer.pipe(
-        Effect.andThen(server =>
-          Effect.log(
-            `Listening on ${server.server.hostname}:${server.server.port}`,
-          )
-        ),
+        Effect.andThen(server => {
+          const { hostname, port } = server.server
+          const addr = hostname === "0.0.0.0"
+            ? getLocalIp()
+            : "localhost"
+
+          return Effect.log(`Listening on http://${addr}:${port}`)
+        }),
       ),
     )
     .pipe(
@@ -226,3 +245,10 @@ function walkBunRoutes(
     return bunRoutes
   })
 }
+
+function getLocalIp(): string | undefined {
+  return Object.values(NOs.networkInterfaces())
+    .flatMap(addresses => addresses ?? [])
+    .find(addr => addr.family === "IPv4" && !addr.internal)
+    ?.address
+}

package/src/bundler/BundleFiles.ts

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem"
+import * as FileSystem from "../FileSystem.ts"
 import * as Array from "effect/Array"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"

package/src/experimental/EncryptedCookies.ts

@@ -1,15 +1,8 @@
-import {
-  Cookies,
-  HttpApp,
-  HttpServerResponse,
-} from "@effect/platform"
-import {
-  Effect,
-  pipe,
-} from "effect"
+import * as Cookies from "../Cookies.ts"
 import * as Config from "effect/Config"
 import * as Context from "effect/Context"
 import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 
 type CookieValue =
@@ -79,8 +72,7 @@ export function layer(options: { secret: string }) {
 export function layerConfig(name = "SECRET_KEY_BASE") {
   return Effect
     .gen(function*() {
-      const secret = yield* pipe(
-        Config.nonEmptyString(name),
+      const secret = yield* Config.nonEmptyString(name).pipe(
         Effect.flatMap((value) => {
           return (value.length < 40)
             ? Effect.fail(new Error("ba"))
@@ -426,26 +418,3 @@ function deriveKey(
     return key
   })
 }
-
-// TODO something si wrong with return type
-export function handleError<E>(
-  app: HttpApp.Default<E | EncryptedCookiesError>,
-) {
-  return Effect.gen(function*() {
-    const res = yield* app.pipe(
-      Effect.catchTag("EncryptedCookiesError", (error) => {
-        return HttpServerResponse.empty()
-      }),
-    )
-
-    return res
-  })
-}
-
-function generateFriendlyKey(bits = 128) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-  const length = Math.ceil(bits / Math.log2(chars.length))
-  const bytes = crypto.getRandomValues(new Uint8Array(length))
-
-  return Array.from(bytes, b => chars[b % chars.length]).join("")
-}

package/src/experimental/index.ts

@@ -1,2 +1 @@
 export * as EncryptedCookies from "./EncryptedCookies.ts"
-export * as SseHttpResponse from "./SseHttpResponse.ts"