effect-start 0.25.0 → 0.26.0

package/dist/Route.js

@@ -1,143 +0,0 @@
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Pipeable from "effect/Pipeable"
-import * as Predicate from "effect/Predicate"
-import * as Entity from "./Entity.js"
-import * as RouteBody from "./RouteBody.js"
-import * as RouteTree from "./RouteTree.js"
-
-export const RouteItems = Symbol()
-export const RouteDescriptor = Symbol()
-// only for structural type matching
-export const RouteBindings = Symbol()
-
-export const TypeId = Symbol.for("effect-start/RouteSet")
-
-const Proto = {
-  [TypeId]: TypeId,
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments)
-  },
-  *[Symbol.iterator]() {
-    yield* items(this)
-  },
-}
-
-export function isRouteSet(input) {
-  return Predicate.hasProperty(input, TypeId)
-}
-
-export function isRoute(input) {
-  return isRouteSet(input) && Predicate.hasProperty(input, "handler")
-}
-
-export function set(
-  items = [],
-  descriptor = {},
-) {
-  return Object.assign(Object.create(Proto), {
-    [RouteItems]: items,
-    [RouteDescriptor]: descriptor,
-  })
-}
-
-export function make(
-  handler,
-  descriptor,
-) {
-  const items = []
-  const route = Object.assign(Object.create(Proto), {
-    [RouteItems]: items,
-    [RouteDescriptor]: descriptor,
-    handler,
-  })
-
-  items.push(route)
-
-  return route
-}
-
-export const empty = set()
-
-export function describe(descriptor) {
-  return set([], descriptor)
-}
-
-export function items(self) {
-  return self[RouteItems]
-}
-
-export function descriptor(
-  self,
-) {
-  if (RouteDescriptor in self) {
-    return self[RouteDescriptor]
-  }
-  return [...self].map((r) => r[RouteDescriptor])
-}
-
-// Shallow merge two object types.
-// For overlapping keys, intersect the values.
-
-export * from "./RouteHook.js"
-export * from "./RouteSchema.js"
-
-export { add, del, get, head, options, patch, post, put, use } from "./RouteMount.js"
-
-export const text = RouteBody.build({
-  format: "text",
-})
-
-export const html = RouteBody.build({
-  format: "html",
-})
-
-export const json = RouteBody.build({
-  format: "json",
-})
-
-export const bytes = RouteBody.build({
-  format: "bytes",
-})
-
-export { render } from "./RouteBody.js"
-
-export { sse } from "./RouteSse.js"
-
-export function redirect(
-  url,
-  options,
-) {
-  return Entity.make("", {
-    status: options?.status ?? 302,
-    headers: {
-      location: url instanceof URL ? url.href : url,
-    },
-  })
-}
-
-export class Routes extends Context.Tag("effect-start/Routes")() {}
-
-export function layer(routes) {
-  return Layer.sync(Routes, () => (RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)))
-}
-
-export { make as tree } from "./RouteTree.js"
-
-export function lazy(
-  load,
-) {
-  let cached
-  return Effect.suspend(() => {
-    if (cached !== undefined) {
-      return Effect.succeed(cached)
-    }
-    return Effect.promise(load).pipe(
-      Effect.map((mod) => {
-        cached = mod.default
-        return cached
-      }),
-    )
-  })
-}

package/dist/RouteBody.js

@@ -1,92 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Entity from "./Entity.js"
-import * as Route from "./Route.js"
-
-const formatToContentType = {
-  text: "text/plain; charset=utf-8",
-  html: "text/html; charset=utf-8",
-  json: "application/json",
-  bytes: "application/octet-stream",
-  "*": undefined,
-}
-
-export function handle(
-  handler,
-) {
-  if (typeof handler === "function") {
-    return (
-      context,
-      next,
-    ) => {
-      const result = (handler)(context, next)
-      const effect = Effect.isEffect(result)
-        ? (result)
-        : (Effect.gen(function* () {
-            return yield* result
-          }))
-      return Effect.map(effect, normalizeToEntity)
-    }
-  }
-  if (Effect.isEffect(handler)) {
-    return (_context, _next) =>
-      Effect.map(handler, normalizeToEntity)
-  }
-  if (Entity.isEntity(handler)) {
-    return (_context, _next) => Effect.succeed(handler)
-  }
-  return (_context, _next) => Effect.succeed(normalizeToEntity(handler))
-}
-
-function normalizeToEntity(value) {
-  if (Entity.isEntity(value)) {
-    return value
-  }
-  return Entity.make(value, { status: 200 })
-}
-
-export function build(descriptors) {
-  return function (handler) {
-    return function (self) {
-      const contentType = formatToContentType[descriptors.format]
-      const baseHandler = handle(handler)
-      const wrappedHandler = (ctx, next) =>
-        Effect.map(baseHandler(ctx, next), (entity) =>
-          entity.headers["content-type"]
-            ? entity
-            : Entity.make(entity.body, {
-                status: entity.status,
-                url: entity.url,
-                headers: { ...entity.headers, "content-type": contentType },
-              }),
-        )
-
-      const route = Route.make(wrappedHandler, descriptors)
-
-      const items = [
-        ...Route.items(self),
-        route,
-      ]
-
-      return Route.set(
-        items,
-        Route.descriptor(self),
-      )
-    }
-  }
-}
-
-export function render(handler) {
-  return function (self) {
-    const route = Route.make(handle(handler), { format: "*" })
-
-    const items = [
-      ...Route.items(self),
-      route,
-    ]
-
-    return Route.set(
-      items,
-      Route.descriptor(self),
-    )
-  }
-}

package/dist/RouteError.js

@@ -1,76 +0,0 @@
-import * as Schema from "effect/Schema"
-
-export class BadRequest extends Schema.TaggedError()("BadRequest", {
-  message: Schema.String,
-}) {
-  static status = 400
-}
-
-export class Unauthorized extends Schema.TaggedError()("Unauthorized", {
-  message: Schema.String,
-}) {
-  static status = 401
-}
-
-export class Forbidden extends Schema.TaggedError()("Forbidden", {
-  message: Schema.String,
-}) {
-  static status = 403
-}
-
-export class NotFound extends Schema.TaggedError()("NotFound", {
-  message: Schema.String,
-}) {
-  static status = 404
-}
-
-export class MethodNotAllowed extends Schema.TaggedError()("MethodNotAllowed", {
-  message: Schema.String,
-}) {
-  static status = 405
-}
-
-export class Conflict extends Schema.TaggedError()("Conflict", {
-  message: Schema.String,
-}) {
-  static status = 409
-}
-
-export class Gone extends Schema.TaggedError()("Gone", {
-  message: Schema.String,
-}) {
-  static status = 410
-}
-
-export class UnprocessableEntity extends Schema.TaggedError()(
-  "UnprocessableEntity",
-  { message: Schema.String },
-) {
-  static status = 422
-}
-
-export class TooManyRequests extends Schema.TaggedError()("TooManyRequests", {
-  message: Schema.String,
-}) {
-  static status = 429
-}
-
-export class InternalServerError extends Schema.TaggedError()(
-  "InternalServerError",
-  { message: Schema.String },
-) {
-  static status = 500
-}
-
-export class NotImplemented extends Schema.TaggedError()("NotImplemented", {
-  message: Schema.String,
-}) {
-  static status = 501
-}
-
-export class ServiceUnavailable extends Schema.TaggedError()(
-  "ServiceUnavailable",
-  { message: Schema.String },
-) {
-  static status = 503
-}

package/dist/RouteHook.js

@@ -1,64 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Entity from "./Entity.js"
-import * as Route from "./Route.js"
-
-export function filter(filterHandler) {
-  const normalized = normalizeFilterHandler(filterHandler)
-
-  return function (
-    self,
-  ) {
-    const route = Route.make(
-      (context, next) =>
-        Effect.gen(function* () {
-          const filterResult = yield* normalized(context)
-
-          const mergedContext = filterResult ? { ...context, ...filterResult.context } : context
-
-          return yield* Entity.resolve(next(mergedContext))
-        }),
-    )
-
-    return Route.set(
-      [...Route.items(self), route],
-      Route.descriptor(self),
-    )
-  }
-}
-
-function isGenerator(value) {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    Symbol.iterator in value &&
-    typeof (value).next === "function"
-  )
-}
-
-function normalizeFilterHandler(
-  handler,
-) {
-  if (typeof handler === "function") {
-    return (context) => {
-      const result = handler(context)
-
-      if (Effect.isEffect(result)) {
-        return result
-      }
-
-      if (isGenerator(result)) {
-        return Effect.gen(function* () {
-          return yield* result
-        })
-      }
-
-      return Effect.succeed(result)
-    }
-  }
-
-  if (Effect.isEffect(handler)) {
-    return (_context) => handler
-  }
-
-  return (_context) => Effect.succeed(handler)
-}