effect-start 0.23.0 → 0.25.0

package/src/Fetch.ts

@@ -0,0 +1,271 @@
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Schedule from "effect/Schedule"
+import * as Entity from "./Entity.ts"
+
+const TypeId: unique symbol = Symbol.for("effect-start/FetchClient")
+type TypeId = typeof TypeId
+
+export type FetchEntity = Entity.Entity<Effect.Effect<Uint8Array, FetchError, never>, FetchError>
+
+export class FetchError extends Data.TaggedError("FetchError")<{
+  readonly reason: "Network" | "Status"
+  readonly cause?: unknown
+  readonly request?: Request
+  readonly response?: FetchEntity
+}> {}
+
+type Next = (request: Request) => Effect.Effect<FetchEntity, FetchError, never>
+
+export type Middleware<E = never, R = never> = (
+  request: Request,
+  next: Next,
+) => Effect.Effect<FetchEntity, FetchError | E, R>
+
+const tryFetch: Middleware = (request) =>
+  Effect.map(
+    Effect.tryPromise({
+      try: () => globalThis.fetch(request),
+      catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
+    }),
+    (response) => Entity.fromResponse(response, request) as FetchEntity,
+  )
+
+const defaultMiddleware: ReadonlyArray<Middleware> = [tryFetch]
+const noopNext: Next = () => Effect.die("no middleware")
+
+function withTrace<E, R>(
+  request: Request,
+  effect: Effect.Effect<FetchEntity, E, R>,
+): Effect.Effect<FetchEntity, E, R> {
+  const url = new URL(request.url)
+
+  return Effect.useSpan(
+    `http.client ${request.method}`,
+    { kind: "client", captureStackTrace: false },
+    (span) => {
+      span.attribute("http.request.method", request.method)
+      span.attribute("url.full", url.toString())
+      span.attribute("url.path", url.pathname)
+      const query = url.search.slice(1)
+      if (query !== "") {
+        span.attribute("url.query", query)
+      }
+      span.attribute("url.scheme", url.protocol.slice(0, -1))
+
+      return Effect.flatMap(Effect.exit(Effect.withParentSpan(effect, span)), (exit) => {
+        if (exit._tag === "Success") {
+          span.attribute("http.response.status_code", exit.value.status ?? 0)
+        }
+        return exit
+      })
+    },
+  )
+}
+
+export interface FetchClient<E = never, R = never> {
+  readonly [TypeId]: TypeId
+  readonly middleware: ReadonlyArray<Middleware<any, any>>
+  readonly fetch: (
+    input: string | URL | Request,
+    init?: RequestInit,
+  ) => Effect.Effect<FetchEntity, FetchError | E, R>
+  readonly get: (
+    input: string | URL | Request,
+    init?: Omit<RequestInit, "method">,
+  ) => Effect.Effect<FetchEntity, FetchError | E, R>
+  readonly post: (
+    input: string | URL | Request,
+    init?: Omit<RequestInit, "method">,
+  ) => Effect.Effect<FetchEntity, FetchError | E, R>
+  readonly use: <E2, R2>(
+    ...middleware: ReadonlyArray<Middleware<E2, R2>>
+  ) => FetchClient<E | E2, R | R2>
+}
+
+export function fetch(
+  input: string | URL | Request,
+  init?: RequestInit,
+): Effect.Effect<FetchEntity, FetchError>
+export function fetch<E, R>(
+  this: FetchClient<E, R>,
+  input: string | URL | Request,
+  init?: RequestInit,
+): Effect.Effect<FetchEntity, FetchError | E, R>
+export function fetch(
+  this: void | FetchClient<any, any>,
+  input: string | URL | Request,
+  init?: RequestInit,
+): Effect.Effect<FetchEntity, any, any> {
+  const middleware: ReadonlyArray<Middleware<any, any>> =
+    (this as any)?.middleware ?? defaultMiddleware
+  return Effect.gen(function* () {
+    const request = new Request(input, init)
+
+    let handler: Next = noopNext as Next
+    for (let i = middleware.length - 1; i >= 0; i--) {
+      const nextHandler = handler
+      handler = ((req: Request) => middleware[i](req, nextHandler)) as Next
+    }
+
+    return yield* withTrace(request, handler(request))
+  }) as any
+}
+
+export function get(
+  input: string | URL | Request,
+  init?: Omit<RequestInit, "method">,
+): Effect.Effect<FetchEntity, FetchError>
+export function get<E, R>(
+  this: FetchClient<E, R>,
+  input: string | URL | Request,
+  init?: Omit<RequestInit, "method">,
+): Effect.Effect<FetchEntity, FetchError | E, R>
+export function get(
+  this: void | FetchClient<any, any>,
+  input: string | URL | Request,
+  init?: Omit<RequestInit, "method">,
+): Effect.Effect<FetchEntity, any, any> {
+  return fetch.call(this as any, input, { ...init, method: "GET" }) as any
+}
+
+export function post(
+  input: string | URL | Request,
+  init?: Omit<RequestInit, "method">,
+): Effect.Effect<FetchEntity, FetchError>
+export function post<E, R>(
+  this: FetchClient<E, R>,
+  input: string | URL | Request,
+  init?: Omit<RequestInit, "method">,
+): Effect.Effect<FetchEntity, FetchError | E, R>
+export function post(
+  this: void | FetchClient<any, any>,
+  input: string | URL | Request,
+  init?: Omit<RequestInit, "method">,
+): Effect.Effect<FetchEntity, any, any> {
+  return fetch.call(this as any, input, { ...init, method: "POST" }) as any
+}
+
+export function use<E2, R2>(...middleware: ReadonlyArray<Middleware<E2, R2>>): FetchClient<E2, R2>
+export function use<E, R, E2, R2>(
+  this: FetchClient<E, R>,
+  ...middleware: ReadonlyArray<Middleware<E2, R2>>
+): FetchClient<E | E2, R | R2>
+export function use(
+  this: void | FetchClient<any, any>,
+  ...middleware: ReadonlyArray<Middleware<any, any>>
+): FetchClient<any, any> {
+  const base = (this as any)?.middleware ?? defaultMiddleware
+  const transport = base[base.length - 1]
+  const existing = base.slice(0, -1)
+  return Object.create(ClientProto, {
+    middleware: { value: [...existing, ...middleware, transport] },
+  }) as FetchClient<any, any>
+}
+
+const ClientProto: any = {
+  [TypeId]: TypeId,
+  middleware: defaultMiddleware,
+  fetch,
+  get,
+  post,
+  use,
+}
+
+export function filterStatus(
+  predicate: (status: number) => boolean,
+  options?: {
+    readonly orElse?: (entity: FetchEntity) => Effect.Effect<FetchEntity, any, any>
+  },
+): Middleware<FetchError> {
+  return ((_request: Request, next: Next) =>
+    Effect.gen(function* () {
+      const entity = yield* next(_request)
+      const status = entity.status ?? 0
+      if (predicate(status)) {
+        return entity
+      }
+      if (options?.orElse) {
+        return yield* options.orElse(entity)
+      }
+      return yield* Effect.fail(new FetchError({ reason: "Status", response: entity }))
+    })) as Middleware<FetchError>
+}
+
+export function filterStatusOk(options?: {
+  readonly orElse?: (entity: FetchEntity) => Effect.Effect<FetchEntity, any, any>
+}): Middleware<FetchError> {
+  return filterStatus((status) => status >= 200 && status < 300, options)
+}
+
+export function followRedirects(options?: { readonly maxRedirects?: number }): Middleware {
+  const maxRedirects = options?.maxRedirects ?? 10
+
+  return (request: Request, next: Next) =>
+    Effect.gen(function* () {
+      let currentRequest = new Request(request.url, {
+        ...request,
+        redirect: "manual",
+      })
+      let redirectCount = 0
+
+      while (true) {
+        const entity = yield* next(currentRequest)
+        const status = entity.status ?? 0
+
+        if (status >= 300 && status < 400) {
+          if (redirectCount >= maxRedirects) {
+            return entity
+          }
+
+          const location = entity.headers["location"]
+          if (!location) {
+            return entity
+          }
+
+          redirectCount++
+          const nextUrl = new URL(location, currentRequest.url)
+
+          if (status === 303) {
+            currentRequest = new Request(nextUrl.toString(), {
+              method: "GET",
+              headers: currentRequest.headers,
+              redirect: "manual",
+            })
+          } else {
+            currentRequest = new Request(nextUrl.toString(), {
+              method: currentRequest.method,
+              headers: currentRequest.headers,
+              body: currentRequest.body,
+              redirect: "manual",
+            })
+          }
+        } else {
+          return entity
+        }
+      }
+    })
+}
+
+export function retry(options: {
+  readonly times?: number
+  readonly delay?: number
+  readonly schedule?: Schedule.Schedule<any, any, any>
+}): Middleware {
+  return ((request: Request, next: Next) => {
+    if (options.schedule) {
+      return Effect.retry(
+        Effect.suspend(() => next(request)),
+        options.schedule,
+      )
+    }
+
+    const times = options.times ?? 3
+    const delay = options.delay ?? 1000
+
+    return Effect.retry(
+      Effect.suspend(() => next(request)),
+      Schedule.intersect(Schedule.recurs(times), Schedule.exponential(delay)),
+    )
+  }) as Middleware
+}

package/src/SqlIntrospect.ts

@@ -1,10 +1,6 @@
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import * as Sql from "./Sql.ts"
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
+import * as Sql from "./sql/Sql.ts"
 
 export interface Column {
   readonly tableSchema: string
@@ -58,10 +54,6 @@ export interface IntrospectOptions {
   readonly indexes?: boolean
 }
 
-// ---------------------------------------------------------------------------
-// SQLite
-// ---------------------------------------------------------------------------
-
 const sqliteColumns = `
   SELECT
     '' as tableSchema,
@@ -115,10 +107,6 @@ const sqliteIndexes = `
   ORDER BY m.name, il.name, ii.seqno
 `
 
-// ---------------------------------------------------------------------------
-// PostgreSQL
-// ---------------------------------------------------------------------------
-
 const postgresColumns = `
   SELECT
     c.table_schema as "tableSchema",
@@ -191,10 +179,6 @@ const postgresIndexes = `
   ORDER BY n.nspname, t.relname, i.relname, array_position(ix.indkey, a.attnum)
 `
 
-// ---------------------------------------------------------------------------
-// SQL Server (MSSQL)
-// ---------------------------------------------------------------------------
-
 const mssqlColumns = `
   SELECT
     s.name as tableSchema,
@@ -265,10 +249,6 @@ const mssqlIndexes = `
   ORDER BY s.name, t.name, i.name, ic.key_ordinal
 `
 
-// ---------------------------------------------------------------------------
-// Dialect resolution
-// ---------------------------------------------------------------------------
-
 export type Dialect = "sqlite" | "postgres" | "mssql"
 
 const dialectQueries: Record<Dialect, { columns: string; foreignKeys: string; indexes: string }> = {
@@ -281,10 +261,6 @@ const dialectQueries: Record<Dialect, { columns: string; foreignKeys: string; in
   mssql: { columns: mssqlColumns, foreignKeys: mssqlForeignKeys, indexes: mssqlIndexes },
 }
 
-// ---------------------------------------------------------------------------
-// Introspect
-// ---------------------------------------------------------------------------
-
 const singleColumnIndexes = (indexes: ReadonlyArray<Index>): Set<string> => {
   const countByIndex = new Map<string, { count: number; columnName: string }>()
   for (const idx of indexes) {
@@ -377,10 +353,6 @@ export const introspect = (
     return { tables: groupByTable(columns, foreignKeys, indexes) }
   })
 
-// ---------------------------------------------------------------------------
-// Column → Schema mapping
-// ---------------------------------------------------------------------------
-
 const dataTypeToSchema = (dataType: string): Schema.Schema.Any | null => {
   const t = dataType.toLowerCase()
   if (
@@ -452,10 +424,6 @@ const columnToSchema = (col: Column): Schema.Schema.Any | Schema.PropertySignatu
   return base
 }
 
-// ---------------------------------------------------------------------------
-// Table → Schema.Struct
-// ---------------------------------------------------------------------------
-
 export interface TableSchema {
   readonly tableName: string
   readonly tableSchema: string
@@ -487,10 +455,6 @@ export const toSchemas = (db: DatabaseSchema): ReadonlyArray<TableSchema> =>
     return s ? [s] : []
   })
 
-// ---------------------------------------------------------------------------
-// Read-only table access
-// ---------------------------------------------------------------------------
-
 export interface SortOrder {
   readonly column: string
   readonly reverse?: boolean
@@ -531,28 +495,51 @@ export interface DatabaseReader {
 
 const escapeIdentifier = (id: string): string => `"${id.replace(/"/g, '""')}"`
 
-const buildWhereClause = (
+const concatSql = (
+  sql: Sql.SqlQuery,
+  fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }>,
+): Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError> => {
+  const strings: Array<string> = []
+  const values: Array<unknown> = []
+  for (let i = 0; i < fragments.length; i++) {
+    const frag = fragments[i]
+    for (let j = 0; j < frag.strings.length; j++) {
+      if (j === 0 && strings.length > 0) {
+        strings[strings.length - 1] += frag.strings[j]
+      } else {
+        strings.push(frag.strings[j])
+      }
+      if (j < frag.values.length) values.push(frag.values[j])
+    }
+  }
+  const tsa = Object.assign([...strings], { raw: strings }) as unknown as TemplateStringsArray
+  return sql(tsa, ...values)
+}
+
+const literal = (text: string) => ({ strings: [text], values: [] as Array<unknown> })
+
+const param = (value: unknown) => ({ strings: ["", ""], values: [value] })
+
+const buildWhereFragments = (
   filters: ReadonlyArray<Filter>,
   columnSet: Set<string>,
-  paramOffset: number,
-): { clause: string; values: Array<unknown> } => {
-  const conditions: Array<string> = []
-  const values: Array<unknown> = []
-  for (const f of filters) {
-    if (!columnSet.has(f.column)) continue
+): Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> => {
+  const parts: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = []
+  const valid = filters.filter((f) => columnSet.has(f.column))
+  if (valid.length === 0) return parts
+  parts.push(literal(" WHERE "))
+  for (let i = 0; i < valid.length; i++) {
+    if (i > 0) parts.push(literal(" AND "))
+    const f = valid[i]
     const col = escapeIdentifier(f.column)
-    const paramIndex = paramOffset + values.length + 1
     if (f.value === null) {
-      conditions.push(f.op === "eq" ? `${col} IS NULL` : `${col} IS NOT NULL`)
+      parts.push(literal(f.op === "eq" ? `${col} IS NULL` : `${col} IS NOT NULL`))
     } else {
-      conditions.push(`${col} ${f.op === "eq" ? "=" : "!="} $${paramIndex}`)
-      values.push(f.value)
+      parts.push(literal(`${col} ${f.op === "eq" ? "=" : "!="} `))
+      parts.push(param(f.value))
     }
   }
-  return {
-    clause: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
-    values,
-  }
+  return parts
 }
 
 const makeTableReader = (ts: TableSchema): TableReader => {
@@ -573,39 +560,46 @@ const makeTableReader = (ts: TableSchema): TableReader => {
     findAll: (options) =>
       Effect.gen(function* () {
         const sql = yield* Sql.SqlClient
-        let query = `SELECT ${selectCols} FROM ${qualifiedName}`
-        const where = options?.filters
-          ? buildWhereClause(options.filters, columnSet, 0)
-          : { clause: "", values: [] }
-        query += where.clause
+        const fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = [
+          literal(`SELECT ${selectCols} FROM ${qualifiedName}`),
+        ]
+        if (options?.filters) {
+          fragments.push(...buildWhereFragments(options.filters, columnSet))
+        }
         if (options?.sort && options.sort.length > 0) {
           const sortClauses = options.sort
             .filter((s) => sortableSet.has(s.column))
             .map((s) => `${escapeIdentifier(s.column)} ${s.reverse ? "DESC" : "ASC"}`)
-          if (sortClauses.length > 0) query += ` ORDER BY ${sortClauses.join(", ")}`
+          if (sortClauses.length > 0) fragments.push(literal(` ORDER BY ${sortClauses.join(", ")}`))
         }
-        if (options?.limit !== undefined) query += ` LIMIT ${Number(options.limit)}`
-        if (options?.offset !== undefined) query += ` OFFSET ${Number(options.offset)}`
-        return yield* sql.unsafe(query, where.values)
+        if (options?.limit !== undefined)
+          fragments.push(literal(` LIMIT ${Math.trunc(Number(options.limit))}`))
+        if (options?.offset !== undefined)
+          fragments.push(literal(` OFFSET ${Math.trunc(Number(options.offset))}`))
+        return yield* concatSql(sql, fragments)
       }),
     findById: (id) =>
       Effect.gen(function* () {
         if (!primaryKey) return null
         const sql = yield* Sql.SqlClient
-        const query = `SELECT ${selectCols} FROM ${qualifiedName} WHERE ${escapeIdentifier(primaryKey.columnName)} = $1`
-        const rows = yield* sql.unsafe(query, [id])
+        const pkCol = escapeIdentifier(primaryKey.columnName)
+        const rows = yield* concatSql(sql, [
+          literal(`SELECT ${selectCols} FROM ${qualifiedName} WHERE ${pkCol} = `),
+          param(id),
+        ])
         return rows[0] ?? null
       }),
     count: (options) =>
       Effect.gen(function* () {
         const sql = yield* Sql.SqlClient
-        let query = `SELECT COUNT(*) as count FROM ${qualifiedName}`
-        const where = options?.filters
-          ? buildWhereClause(options.filters, columnSet, 0)
-          : { clause: "", values: [] }
-        query += where.clause
-        const rows = yield* sql.unsafe<{ count: number }>(query, where.values)
-        return Number(rows[0].count)
+        const fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = [
+          literal(`SELECT COUNT(*) as count FROM ${qualifiedName}`),
+        ]
+        if (options?.filters) {
+          fragments.push(...buildWhereFragments(options.filters, columnSet))
+        }
+        const rows = yield* concatSql(sql, fragments)
+        return Number((rows[0] as any).count)
       }),
   }
 }

package/src/Start.ts

@@ -1,14 +1,15 @@
 import type * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
 import type * as ChildProcess from "./ChildProcess.ts"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
 import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.ts"
+import * as StartApp from "./StartApp.ts"
 
 export function layer<
   Layers extends [Layer.Layer<never, any, any>, ...Array<Layer.Layer<never, any, any>>],
@@ -63,11 +64,26 @@ export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<La
   return result as AnyLayer
 }
 
-export function serve<
-  ROut,
-  E,
-  RIn extends BunServer.BunServer | FileSystem.FileSystem | ChildProcess.ChildProcessSpawner,
->(
+export type PlatformServices =
+  | BunServer.BunServer
+  | FileSystem.FileSystem
+  | ChildProcess.ChildProcessSpawner
+  | StartApp.StartApp
+
+export const Live: Layer.Layer<
+  Exclude<PlatformServices, BunServer.BunServer>,
+  never,
+  never
+> = Layer.mergeAll(
+  NodeFileSystem.layer,
+  BunChildProcessSpawner.layer,
+  Layer.effect(
+    StartApp.StartApp,
+    Deferred.make<BunServer.BunServer>().pipe(Effect.map((server) => ({ server }))),
+  ),
+)
+
+export function serve<ROut, E, RIn extends PlatformServices>(
   load: () => Promise<{
     default: Layer.Layer<ROut, E, RIn>
   }>,
@@ -79,24 +95,10 @@ export function serve<
     Layer.unwrapEffect,
   )
 
-  const serverLayer = Layer.scoped(
-    BunServer.BunServer,
-    Effect.gen(function* () {
-      const existing = yield* Effect.serviceOption(BunServer.BunServer)
-      if (Option.isSome(existing)) return existing.value
-      return yield* BunServer.make({})
-    }),
-  )
-
-  const appLayerResolved = Function.pipe(
-    appLayer,
-    Layer.provide(serverLayer),
-    Layer.provide(NodeFileSystem.layer),
-    Layer.provide(BunChildProcessSpawner.layer),
-  )
+  const appLayerResolved = Function.pipe(appLayer, Layer.provideMerge(Live))
 
   const composed = Function.pipe(
-    serverLayer,
+    BunServer.layerStart(),
     BunServer.withLogAddress,
     Layer.provide(appLayerResolved),
   ) as Layer.Layer<BunServer.BunServer, never, never>

package/src/StartApp.ts

@@ -0,0 +1,11 @@
+import * as Context from "effect/Context"
+import type * as Deferred from "effect/Deferred"
+import type * as BunServer from "./bun/BunServer.ts"
+
+export namespace StartApp {
+  export interface Service {
+    readonly server: Deferred.Deferred<BunServer.BunServer>
+  }
+}
+
+export class StartApp extends Context.Tag("effect-start/StartApp")<StartApp, StartApp.Service>() {}