@effect-app/infra 0.198.2 → 0.199.2

package/src/api/express/makeJsonSchema.test.ts.bak

@@ -1,76 +0,0 @@
-import { InvalidStateError } from "../../errors.js"
-import { checkPaths } from "./makeJsonSchema.js"
-
-const path = { path: "/securities/:id/search/:id2", method: "get" }
-
-const equalPaths = [
-  "/securities/:idt/search/:id2",
-  "/securities/:id/search/:id2t",
-  "/securities/:idt/search/:id2t"
-]
-  .map((path) => ({ path, method: "get" }))
-
-const differentPaths: {
-  path: string
-  method: string
-}[] = [
-  "/securities/search/:id2",
-  "/securities/:id/search/",
-  "/securities/:id/search/:id2",
-  "/securities/:id/:id2/search/:id3"
-]
-  .map((path) => ({ path, method: "get" }))
-  .concat([
-    "/securities/:idt/search/:id2"
-  ]
-    .map((path) => ({ path, method: "post" })))
-
-test("works", async () => {
-  expect(await (checkPaths(differentPaths)).runPromise).toStrictEqual(differentPaths)
-
-  for (const p of equalPaths) {
-    expect(await checkPaths([path, p]).runPromiseExit).toStrictEqual(
-      Exit.fail(new InvalidStateError(`Duplicate method ${p.method} for path ${p.path}`))
-    )
-  }
-
-  // should it error out? I think not
-  // expect(await checkPaths(["a/:p1/c/:p2", "a/b"].map((path) => ({ path, method: "get" }))).runPromiseEither)
-  //   .toStrictEqual(
-  //     Either.left(new InvalidStateError(`Path /a/b/ is shadowed by /a/:p1/`))
-  //   )
-
-  // should not error out
-  // expect(await checkPaths([{ path: "a/:p1/c/:p2", method: "post" }, { path: "a/b", method: "get" }]).runPromiseEither)
-  //   .toStrictEqual(
-  //     Either.left(new InvalidStateError(`Path /a/b/ is shadowed by /a/:p1/`))
-  //   )
-
-  // should not error out
-  // expect(await checkPaths([{ path: "a/:param/c/d", method: "get" }, { path: "a/b/c/e", method: "get" }]).runPromiseEither)
-  //   .toStrictEqual(
-  //     Either.left(new InvalidStateError(`Path /a/b/ is shadowed by /a/:p1/`))
-  //   )
-
-  // it should error out
-  // expect(await checkPaths(["a/:p1/c/:p2", "a/:p111/c/d"].map((path) => ({ path, method: "get" }))).runPromiseEither)
-  //   .toStrictEqual(
-  //     Either.left(new InvalidStateError(`Path /a/:p1/c/d/ is shadowed by /a/:p1/c/:p2/`))
-  //   )
-})
-
-// it should log
-// test("log shadowing", async () => {
-//   const arr: string[] = []
-//   const paths = ["a/b", "a/:p"].map((path) => ({ path, method: "get" }))
-
-//   const CustomLogger = Logger.make<string, void>((_, __, message) => {
-//     arr.push(message)
-//   })
-
-//   await checkPaths(paths)
-//     .provideLayer(Logger.replace(Logger.defaultLogger, CustomLogger))
-//     .runPromise
-
-//   expect(arr).toStrictEqual([`Path /a/:p/ is partially shadowed by /a/b/`])
-// })

package/src/api/express/makeJsonSchema.ts.bak

@@ -1,166 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { InvalidStateError } from "../../errors.js"
-import * as RS from "./schema/routing.js"
-
-type Methods = "GET" | "PUT" | "POST" | "PATCH" | "DELETE"
-
-const rx = /:(\w+)/g
-
-type _A<C> = C extends ReadonlyArray<infer A> ? A : never
-
-class PathsTree {
-  public readonly methods: string[]
-  public readonly params: { [key: number]: PathsTree | undefined }
-  public readonly subpaths: { [key: string]: PathsTree | undefined }
-  public readonly path: string
-
-  constructor(path: string) {
-    this.methods = []
-    this.params = {}
-    this.subpaths = {}
-    this.path = path
-  }
-}
-
-// interface Match {
-//   _tag: "resource" | "param"
-//   value: string
-// }
-
-// function checkShadowing(
-//   pathNavigator: PathsTree,
-//   match: Match
-// ) {
-//   return Effect.gen(function*($) {
-//     switch (match._tag) {
-//       case "resource": {
-//         // check shadowing: if 'a/:param' comes before 'a/b', then 'a/b' is shadowed
-//         if (pathNavigator.params[1]) {
-//           return yield* $(
-//             new InvalidStateError(
-//               `Path ${pathNavigator.path}${match.value}/ is shadowed by ${pathNavigator.params[1].path}`
-//             )
-//           )
-//         }
-//         break
-//       }
-//       case "param": {
-//         // check shadowing: if 'a/b' comes before 'a/:param', then 'a/"param' is partially shadowed
-//         const subpaths = Object.getOwnPropertyNames(pathNavigator.subpaths)
-//         if (subpaths.length > 0) {
-//           yield* $(subpaths.forEachEffect((s) =>
-//             Effect.logInfo(
-//               `Path ${pathNavigator.path}:${match.value}/ is partially shadowed by ${pathNavigator.subpaths[s]!.path}`
-//             )
-//           ))
-//         }
-//         break
-//       }
-//     }
-//   })
-// }
-
-export function checkPaths<T extends { path: string; method: string }>(
-  paths: readonly T[]
-) {
-  return Effect.gen(function*($) {
-    const pathMethods: PathsTree = new PathsTree("/")
-    const regex = /(?:^|\/)([^/:\n]+)|:(\w+)/g
-    for (const path of paths) {
-      const matches = [...path.path.matchAll(regex)]
-        .map((match) =>
-          match[1]
-            ? { _tag: "resource", value: match[1] } as const
-            : { _tag: "param", value: match[2]! } as const
-        )
-
-      let pathNavigator = pathMethods
-      for (let i = 0; i < matches.length;) {
-        const match = matches[i]!
-
-        // yield* $(checkShadowing(pathNavigator, match))
-
-        switch (match._tag) {
-          case "resource": {
-            if (!(match.value in pathNavigator.subpaths)) {
-              pathNavigator.subpaths[match.value] = new PathsTree(`${pathNavigator.path}${match.value}/`)
-            }
-
-            pathNavigator = pathNavigator.subpaths[match.value]!
-            i++
-            break
-          }
-          case "param": {
-            const paramsNames = [match.value]
-            let numberOfParams = 1
-            while (i < matches.length && matches[i + 1]?._tag === "param") {
-              numberOfParams++
-              i++
-              paramsNames.push(matches[i]!.value)
-            }
-
-            if (!(numberOfParams in pathNavigator.params)) {
-              pathNavigator.params[numberOfParams] = new PathsTree(
-                `${pathNavigator.path}:${paramsNames.join("/:")}/`
-              )
-            }
-            pathNavigator = pathNavigator.params[numberOfParams]!
-            i++
-            break
-          }
-        }
-      }
-
-      if (pathNavigator.methods.includes(path.method)) {
-        // throw duplicate path-method error
-        return yield* $(new InvalidStateError(`Duplicate method ${path.method} for path ${path.path}`))
-      }
-      pathNavigator.methods.push(path.method)
-    }
-
-    return paths
-  })
-}
-
-/**
- * Work in progress JSONSchema generator.
- */
-export function makeJsonSchema(r: Iterable<RS.RouteDescriptorAny>) {
-  return Chunk
-    .fromIterable(r)
-    .forEachEffect(RS.makeFromSchema)
-    .flatMap(checkPaths)
-    .map((e) => {
-      const map = ({ method, path, responses, ...rest }: _A<typeof e>) => ({
-        [method]: {
-          ...rest,
-          responses: (responses as Array<any>).reduce(
-            (prev, cur) => {
-              prev[cur.statusCode] = cur.type
-              return prev
-            },
-            {} as Record<Response["statusCode"], Response["type"]>
-          )
-        }
-      })
-      return e.reduce(
-        (prev, e) => {
-          const path = e.path.split("?")[0].replace(rx, (_a, b) => `{${b}}`)
-          prev[path] = {
-            ...prev[path],
-            ...map(e) as any
-          }
-          return prev
-        },
-        {} as Record<string, Record<Methods, ReturnType<typeof map>>>
-      )
-    })
-}
-
-class Response {
-  constructor(
-    public readonly statusCode: number,
-    public readonly type: any // string | JSONSchema | SubSchema
-  ) {}
-}

package/src/api/express/makeOpenApiSpecs.ts.bak

@@ -1,62 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type * as Plutus from "@effect-app/infra-adapters/Openapi/atlas-plutus"
-import type { JSONSchema, SubSchema } from "@effect-app/infra-adapters/Openapi/atlas-plutus/JsonSchema/index"
-import { References } from "@effect-app/infra-adapters/Openapi/atlas-plutus/Schema/index"
-import { makeJsonSchema } from "./makeJsonSchema.js"
-import type { RouteDescriptorAny } from "./schema/routing.js"
-
-export function makeOpenApiSpecs(
-  rdescs: Iterable<RouteDescriptorAny>,
-  info: Plutus.Info
-) {
-  return Effect.gen(function*($) {
-    const ref = yield* $(Ref.make<Map<string, JSONSchema | SubSchema>>(new Map()))
-    const paths = yield* $(makeJsonSchema(rdescs).provideService(References, { ref }))
-    const refs = yield* $(ref.get)
-    const parameterRefs: Record<string, any> = {} // todos
-    const schemas: Record<string, any> = {}
-    const securitySchemes = {
-      bearerAuth: {
-        type: "http",
-        scheme: "bearer",
-        bearerFormat: "JWT"
-      }
-    } // { basicAuth: { type: "http", scheme: "basic" } }
-    const components = { securitySchemes, schemas, parameters: parameterRefs }
-
-    for (const entry of refs.entries()) {
-      // eslint-disable-next-line prefer-destructuring
-      schemas[entry[0]] = entry[1]
-    }
-
-    return {
-      openapi: "3.0.0",
-      info: {
-        title: info.title,
-        description: info.description,
-        termsOfService: info.tos,
-        contact: info.contact
-          ? {
-            name: info.contact.name,
-            email: info.contact.email,
-            url: info.contact.url
-          }
-          : undefined,
-        license: info.license
-          ? {
-            name: info.license.name,
-            url: info.license.url
-          }
-          : undefined,
-        version: info.version
-      },
-      tags: [],
-      paths,
-      components,
-      security: [
-        { bearerAuth: [] }
-      ]
-      // test,
-    }
-  })
-}

package/src/api/http.ts

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import type { Route as HttpRoute, Router as HttpRouter } from "@effect/platform/Http/Router"
-
-export type { HttpApp } from "@effect/platform/Http/App"
-export type { Body as HttpBody } from "@effect/platform/Http/Body"
-export * as HttpHeaders from "@effect/platform/Http/Headers"
-export type { Middleware as HttpMiddleware } from "@effect/platform/Http/Middleware"
-export { RouteContext as HttpRouteContext } from "@effect/platform/Http/Router"
-export { RequestError as HttpRequestError } from "@effect/platform/Http/ServerError"
-export { ServerRequest as HttpServerRequest } from "@effect/platform/Http/ServerRequest"
-export type { ServerResponse as HttpServerResponse } from "@effect/platform/Http/ServerResponse"
-export type { HttpRoute, HttpRouter }
-export * as HttpServer from "@effect/platform/Http/Server"
-
-/**
- * @tsplus unify effect/platform/Http/Router/Route
- */
-export function unifyRoute<X extends HttpRoute<any, any>>(
-  self: X
-): HttpRoute<
-  X extends HttpRoute<infer EX, any> ? EX : never,
-  X extends HttpRoute<any, infer AX> ? AX : never
-> {
-  return self
-}

package/tsplus.config.json

@@ -1,9 +0,0 @@
-{
-  "importMap": {
-    "^(.*)/packages/prelude/src/(.*)\\.[cm]?[tj]s$": "effect-app/$2",
-    "^(.*)/packages/(.*)/src/(.*)\\.[cm]?[tj]s$": "@effect-app/$2/$3",
-    "^(.*)/node_modules/@effect-app/prelude/src/(.*)\\.[cm]?[tj]s$": "effect-app/$2",
-    "^(.*)/node_modules/@effect-app/(.*)/src/(.*)\\.[cm]?[tj]s$": "@effect-app/$2/$3",
-    ".pnpm/[^\/]*/node_modules/(.*)": "$1"
-  }
-}