effect-start 0.23.1 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.23.1",
+  "version": "0.26.0",
   "license": "MIT",
   "files": [
     "src/",
@@ -12,92 +12,24 @@
   ],
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "bun": "./src/index.ts",
-      "default": "./dist/index.js"
-    },
-    "./bun": {
-      "types": "./dist/bun/index.d.ts",
-      "bun": "./src/bun/index.ts",
-      "default": "./dist/bun/index.js"
-    },
-    "./client": {
-      "types": "./dist/client/index.d.ts",
-      "bun": "./src/client/index.ts",
-      "default": "./dist/client/index.js"
-    },
-    "./testing": {
-      "types": "./dist/testing/index.d.ts",
-      "bun": "./src/testing/index.ts",
-      "default": "./dist/testing/index.js"
-    },
-    "./console": {
-      "types": "./dist/console/index.d.ts",
-      "bun": "./src/console/index.ts",
-      "default": "./dist/console/index.js"
-    },
-    "./sql/*": {
-      "types": "./dist/sql/*/index.d.ts",
-      "bun": "./src/sql/*/index.ts",
-      "default": "./dist/sql/*/index.js"
-    },
-    "./x/*": {
-      "types": "./dist/x/*/index.d.ts",
-      "bun": "./src/x/*/index.ts",
-      "default": "./dist/x/*/index.js"
-    },
-    "./x/tailwind/plugin": {
-      "types": "./dist/x/tailwind/plugin.d.ts",
-      "bun": "./src/x/tailwind/plugin.ts",
-      "default": "./dist/x/tailwind/plugin.js"
-    },
-    "./System": {
-      "types": "./dist/System.d.ts",
-      "bun": "./src/System.ts",
-      "default": "./dist/System.js"
-    },
-    "./Unique": {
-      "types": "./dist/Unique.d.ts",
-      "bun": "./src/Unique.ts",
-      "default": "./dist/Unique.js"
-    },
-    "./FileRouter": {
-      "types": "./dist/FileRouter.d.ts",
-      "bun": "./src/FileRouter.ts",
-      "default": "./dist/FileRouter.js"
-    },
-    "./FileSystem": {
-      "types": "./dist/FileSystem.d.ts",
-      "bun": "./src/FileSystem.ts",
-      "default": "./dist/FileSystem.js"
-    },
-    "./experimental": {
-      "types": "./dist/experimental/index.d.ts",
-      "bun": "./src/experimental/index.ts",
-      "default": "./dist/experimental/index.js"
-    },
+    ".": "./src/index.ts",
+    "./bun": "./src/bun/index.ts",
+    "./client": "./src/client/index.ts",
+    "./testing": "./src/testing/index.ts",
+    "./console": "./src/console/index.ts",
+    "./sql/*": "./src/sql/*/index.ts",
+    "./x/*": "./src/x/*/index.ts",
+    "./x/tailwind/plugin": "./src/x/tailwind/plugin.ts",
+    "./System": "./src/System.ts",
+    "./Unique": "./src/Unique.ts",
+    "./FileRouter": "./src/FileRouter.ts",
+    "./FileSystem": "./src/FileSystem.ts",
+    "./experimental": "./src/experimental/index.ts",
     "./client/assets.d.ts": "./src/assets.d.ts",
-    "./hyper": {
-      "types": "./dist/hyper/index.d.ts",
-      "bun": "./src/hyper/index.ts",
-      "default": "./dist/hyper/index.js"
-    },
-    "./jsx-runtime": {
-      "types": "./src/hyper/jsx-runtime.ts",
-      "bun": "./src/hyper/jsx-runtime.ts",
-      "default": "./dist/hyper/jsx-runtime.js"
-    },
-    "./jsx-dev-runtime": {
-      "types": "./src/hyper/jsx-runtime.ts",
-      "bun": "./src/hyper/jsx-runtime.ts",
-      "default": "./dist/hyper/jsx-runtime.js"
-    },
-    "./datastar": {
-      "types": "./dist/datastar/index.d.ts",
-      "bun": "./src/datastar/index.ts",
-      "default": "./dist/datastar/index.js"
-    },
+    "./hyper": "./src/hyper/index.ts",
+    "./jsx-runtime": "./src/hyper/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/hyper/jsx-runtime.ts",
+    "./datastar": "./src/datastar/index.ts",
     "./lint/plugin": "./src/lint/plugin.js",
     "./package.json": "./package.json"
   },

package/src/Development.ts

@@ -104,10 +104,12 @@ export const layerWatch = (opts?: {
   filter?: (event: FileSystem.WatchEvent) => boolean
 }) => Layer.scoped(Development, watch(opts))
 
+export const option = Effect.serviceOption(Development)
+
 export const stream = (): Stream.Stream<DevelopmentEvent> =>
   Stream.unwrap(
     Function.pipe(
-      Effect.serviceOption(Development),
+      option,
       Effect.map(
         Option.match({
           onNone: () => Stream.empty,

package/src/Entity.ts

@@ -325,6 +325,23 @@ export function length(self: Entity): number | undefined {
   return undefined
 }
 
+export function fromResponse(
+  response: Response,
+  request?: Request,
+): Entity<Effect.Effect<Uint8Array, Error, never>, Error> {
+  return make(
+    Effect.tryPromise({
+      try: () => response.arrayBuffer().then((buf) => new Uint8Array(buf)),
+      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+    }),
+    {
+      headers: Object.fromEntries(response.headers.entries()),
+      status: response.status,
+      url: response.url || request?.url,
+    },
+  )
+}
+
 function mismatch(expected: Schema.Schema.Any, actual: unknown): ParseResult.ParseError {
   return new ParseResult.ParseError({
     issue: new ParseResult.Type(expected.ast, actual),

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)
       }),
   }
 }