effect-start 0.28.0 → 0.30.0

package/src/PlatformError.ts

@@ -1,73 +0,0 @@
-/*
- * Adapted from @effect/platform
- */
-import type * as Cause from "effect/Cause"
-import * as Data from "effect/Data"
-import * as Predicate from "effect/Predicate"
-import type * as Types from "effect/Types"
-
-export const TypeId: unique symbol = Symbol.for("@effect/platform/Error/PlatformError")
-
-export type TypeId = typeof TypeId
-
-export const isPlatformError = (u: unknown): u is PlatformError => Predicate.hasProperty(u, TypeId)
-
-export const TypeIdError = <const TypeId extends symbol, const Tag extends string>(
-  typeId: TypeId,
-  tag: Tag,
-): (new <A extends Record<string, any>>(
-  args: Types.Simplify<A>,
-) => Cause.YieldableError & Record<TypeId, TypeId> & { readonly _tag: Tag } & Readonly<A>) => {
-  class Base extends Data.Error<{}> {
-    readonly _tag = tag
-  }
-  ;(Base.prototype as any)[typeId] = typeId
-  ;(Base.prototype as any).name = tag
-  return Base as any
-}
-
-export type SystemErrorReason =
-  | "AlreadyExists"
-  | "BadResource"
-  | "Busy"
-  | "InvalidData"
-  | "NotFound"
-  | "PermissionDenied"
-  | "TimedOut"
-  | "UnexpectedEof"
-  | "Unknown"
-  | "WouldBlock"
-  | "WriteZero"
-
-export class BadArgument extends Data.TaggedError("BadArgument")<{
-  module: string
-  method: string
-  description?: string | undefined
-  cause?: unknown
-}> {
-  readonly [TypeId]: typeof TypeId = TypeId
-
-  get message(): string {
-    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`
-  }
-}
-
-export class SystemError extends Data.TaggedError("SystemError")<{
-  reason: SystemErrorReason
-  module: string
-  method: string
-  description?: string | undefined
-  syscall?: string | undefined
-  pathOrDescriptor?: string | number | undefined
-  cause?: unknown
-}> {
-  readonly [TypeId]: typeof TypeId = TypeId
-
-  get message(): string {
-    return `${this.reason}: ${this.module}.${this.method}${
-      this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
-    }${this.description ? `: ${this.description}` : ""}`
-  }
-}
-
-export type PlatformError = BadArgument | SystemError

package/src/TuplePathPattern.ts

@@ -1,75 +0,0 @@
-export type PathTuple = ReadonlyArray<string | [string, string?, string?] | [[string]]>
-
-export function format(tuple: PathTuple): `/${string}` {
-  return ("/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "[[" + el[0][0] + "]]"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + "[" + name + "]" + (suffix ?? "")
-      })
-      .join("/")) as `/${string}`
-}
-
-export function toColon(tuple: PathTuple): string {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "*"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + ":" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export const toHono = toColon
-
-export function toExpress(tuple: PathTuple): string {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "*" + el[0][0]
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + ":" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export const toEffect = toColon
-
-export function toURLPattern(tuple: PathTuple): string {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return ":" + el[0][0] + "+"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + ":" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export function toRemix(tuple: PathTuple): string {
-  return (
-    "/" +
-    tuple
-      .map((el) => {
-        if (typeof el === "string") return el
-        if (Array.isArray(el[0])) return "$"
-        const [name, suffix, prefix] = el
-        return (prefix ?? "") + "$" + name + (suffix ?? "")
-      })
-      .join("/")
-  )
-}
-
-export const toBun = toColon

package/src/hyper/Hyper.ts

@@ -1,55 +0,0 @@
-import * as Context from "effect/Context"
-import * as Fiber from "effect/Fiber"
-import * as Option from "effect/Option"
-import type { JSX } from "./jsx.d.ts"
-
-type Elements = JSX.IntrinsicElements
-
-type Children = JSX.Children
-
-export type { Children, Elements, JSX }
-
-export class Hyper extends Context.Tag("Hyper")<Hyper, {}>() {}
-
-const NoChildren: ReadonlyArray<never> = Object.freeze([])
-
-type Primitive = string | number | boolean | null | undefined
-
-export type HyperType = string | HyperComponent
-
-export type HyperProps = {
-  [key: string]: Primitive | ReadonlyArray<Primitive> | HyperNode | HyperNode[] | null | undefined
-}
-
-export type HyperComponent = (props: HyperProps) => HyperNode | Primitive
-
-export interface HyperNode {
-  type: HyperType
-  props: HyperProps
-}
-
-export function h(type: HyperType, props: HyperProps): HyperNode {
-  return {
-    type,
-    props: {
-      ...props,
-      children: props.children ?? NoChildren,
-    },
-  }
-}
-
-export function unsafeUse<Value>(tag: Context.Tag<any, Value>) {
-  const currentFiber = Option.getOrThrow(Fiber.getCurrentFiber())
-  const context = currentFiber.currentContext
-
-  return Context.unsafeGet(context, tag)
-}
-
-export type GenericJsxObject = {
-  type: any
-  props: any
-}
-
-export function isGenericJsxObject(value: unknown): value is GenericJsxObject {
-  return typeof value === "object" && value !== null && "type" in value && "props" in value
-}

package/src/hyper/HyperNode.ts

@@ -1,34 +0,0 @@
-export const TypeId = Symbol.for("effect-start/HyperNode")
-export type TypeId = typeof TypeId
-
-const NoChildren: ReadonlyArray<never> = Object.freeze([])
-
-type Primitive = string | number | boolean | null | undefined
-
-export type Type = string | HyperComponent
-
-export type Props = {
-  [key: string]:
-    | Primitive
-    | HyperNode
-    | Iterable<Primitive | HyperNode>
-    | Record<string, unknown>
-    | ((window: Window) => void)
-}
-
-export type HyperComponent = (props: Props) => HyperNode | Primitive
-
-export interface HyperNode {
-  type: Type
-  props: Props
-}
-
-export function make(type: Type, props: Props): HyperNode {
-  return {
-    type,
-    props: {
-      ...props,
-      children: props.children ?? NoChildren,
-    },
-  }
-}

package/src/hyper/HyperRoute.ts

@@ -1,59 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Entity from "../Entity.ts"
-import * as Route from "../Route.ts"
-import type * as RouteBody from "../RouteBody.ts"
-import type * as Values from "../Values.ts"
-import * as HyperHtml from "./HyperHtml.ts"
-import type { JSX } from "./jsx.d.ts"
-
-function renderValue(
-  value: JSX.Children | Entity.Entity<JSX.Children>,
-): string | Entity.Entity<string> {
-  if (Entity.isEntity(value)) {
-    return Entity.make(HyperHtml.renderToString(value.body), {
-      status: value.status,
-      url: value.url,
-      headers: value.headers,
-    })
-  }
-  return HyperHtml.renderToString(value)
-}
-
-function normalizeToEffect<B, A, E, R>(
-  handler: RouteBody.HandlerInput<B, A, E, R>,
-  context: Values.Simplify<B>,
-  next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<A>,
-): Effect.Effect<A | Entity.Entity<A>, E, R> {
-  if (Effect.isEffect(handler)) {
-    return handler
-  }
-  if (typeof handler === "function") {
-    const result = (handler as Function)(context, next)
-    if (Effect.isEffect(result)) {
-      return result as Effect.Effect<A | Entity.Entity<A>, E, R>
-    }
-    return Effect.gen(function* () {
-      return yield* result
-    }) as Effect.Effect<A | Entity.Entity<A>, E, R>
-  }
-  return Effect.succeed(handler as A | Entity.Entity<A>)
-}
-
-export function html<
-  D extends Route.RouteDescriptor.Any,
-  B extends {},
-  I extends Route.Route.Tuple,
-  E = never,
-  R = never,
->(
-  handler: RouteBody.HandlerInput<
-    NoInfer<D & B & Route.ExtractBindings<I> & { format: "html" }>,
-    JSX.Children,
-    E,
-    R
-  >,
-) {
-  return Route.html<D, B, I, string, E, R>((context, next) =>
-    Effect.map(normalizeToEffect(handler, context, next as never), renderValue),
-  )
-}

package/src/hyper/html.ts

@@ -1,47 +0,0 @@
-const HtmlStringSymbol = Symbol.for("HtmlString")
-
-export interface HtmlString {
-  readonly [HtmlStringSymbol]: true
-  readonly value: string
-}
-
-const makeHtmlString = (value: string): HtmlString => ({
-  [HtmlStringSymbol]: true,
-  value,
-})
-
-const isHtmlString = (value: unknown): value is HtmlString =>
-  typeof value === "object" && value !== null && HtmlStringSymbol in value
-
-export type HtmlValue =
-  | string
-  | number
-  | bigint
-  | boolean
-  | null
-  | undefined
-  | HtmlString
-  | Function
-  | Record<string, unknown>
-  | ReadonlyArray<HtmlValue>
-
-const resolveValue = (value: HtmlValue): string => {
-  if (value === null || value === undefined || value === false || value === true) return ""
-  if (isHtmlString(value)) return value.value
-  if (Array.isArray(value)) return (value as Array<HtmlValue>).map(resolveValue).join("")
-  if (typeof value === "function") return value.toString()
-  if (typeof value === "object") return JSON.stringify(value)
-  if (typeof value === "string") return value
-  return String(value)
-}
-
-export const html = (strings: TemplateStringsArray, ...values: Array<HtmlValue>): HtmlString => {
-  let result = strings[0]
-  for (let i = 0; i < values.length; i++) {
-    result += resolveValue(values[i])
-    result += strings[i + 1]
-  }
-  return makeHtmlString(result)
-}
-
-html.raw = (value: string): HtmlString => makeHtmlString(value)

package/src/hyper/index.ts

@@ -1,6 +0,0 @@
-export * as Hyper from "./Hyper.ts"
-export { html } from "./html.ts"
-export type { HtmlString, HtmlValue } from "./html.ts"
-export * as HyperHtml from "./HyperHtml.ts"
-export * as HyperNode from "./HyperNode.ts"
-export * as HyperRoute from "./HyperRoute.ts"

package/src/hyper/jsx-runtime.ts

@@ -1,15 +0,0 @@
-import * as HyperNode from "./HyperNode.ts"
-import type { JSX } from "./jsx.d.ts"
-
-function Fragment(props: { children: JSX.Element }) {
-  return props.children
-}
-
-function jsx<T extends HyperNode.Type>(
-  type: T,
-  props: T extends string ? HyperNode.Props : T extends (props: infer P) => any ? P : never,
-): HyperNode.HyperNode {
-  return HyperNode.make(type, props)
-}
-
-export { Fragment, type JSX, jsx, jsx as jsxDEV, jsx as jsxs }

package/src/tower/Tower.ts

@@ -1,47 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Route from "../Route.ts"
-import * as RouteTree from "../RouteTree.ts"
-import * as sqlBun from "effect-start/sql/bun"
-import type * as SqlClient from "../sql/SqlClient.ts"
-import * as TowerErrors from "./TowerErrors.ts"
-import * as TowerLogger from "./TowerLogger.ts"
-import * as TowerMetrics from "./TowerMetrics.ts"
-import * as TowerProcess from "./TowerProcess.ts"
-import * as TowerStore from "./TowerStore.ts"
-import * as TowerTracer from "./TowerTracer.ts"
-import consoleRoutes from "./routes/tree.ts"
-
-export function layer(
-  options?: TowerStore.TowerStoreOptions & {
-    readonly sqlLayer?: Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError>
-  },
-): Layer.Layer<TowerStore.TowerStore> {
-  const sqlLayer =
-    options?.sqlLayer ?? sqlBun.layer({ adapter: "sqlite", filename: ":memory:" } as any)
-  const store = TowerStore.layer(options).pipe(Layer.provide(sqlLayer), Layer.orDie)
-  const features = Layer.mergeAll(
-    TowerTracer.layer,
-    TowerLogger.layer,
-    TowerMetrics.layer,
-    TowerErrors.layer,
-    TowerProcess.layer,
-  ).pipe(Layer.provide(store))
-  return Layer.merge(store, features)
-}
-
-export function layerRoutes(options?: { prefix?: string }) {
-  const prefix = options?.prefix ?? "/tower"
-
-  return Layer.effect(
-    Route.Routes,
-    Effect.gen(function* () {
-      const existing = yield* Route.Routes
-      TowerStore.store.prefix = prefix
-      const tree = Route.tree({
-        [prefix as "/"]: consoleRoutes,
-      })
-      return RouteTree.merge(existing, tree)
-    }),
-  )
-}

package/src/tower/index.ts

@@ -1,3 +0,0 @@
-export * as Tower from "./Tower.ts"
-export * as TowerStore from "./TowerStore.ts"
-export * as Simulation from "./Simulation.ts"

package/src/tower/routes/route.tsx

@@ -1,8 +0,0 @@
-import * as Route from "../../Route.ts"
-import * as TowerStore from "../TowerStore.ts"
-
-export default Route.get(
-  Route.render(function* () {
-    return Route.redirect(`${TowerStore.store.prefix}/traces`)
-  }),
-)