@effect-app/infra 0.7.0 → 0.8.1

package/_src/api/app.ts.bak

@@ -0,0 +1,125 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { flow } from "@effect-app/core/Function"
+import * as MO from "@effect-app/schema"
+
+import { NotFoundError, UnauthorizedError } from "./errors.js"
+
+export function handle<
+  TModule extends Record<
+    string,
+    any // { Model: MO.SchemaAny; new (...args: any[]): any } | MO.SchemaAny
+  >
+>(
+  _: TModule & { ResponseOpenApi?: any },
+  adaptResponse?: any
+): <R, E>(
+  h: (
+    r: InstanceType<
+      MO.GetRequest<TModule> extends { new(...args: any[]): any } ? MO.GetRequest<TModule>
+        : never
+    >
+  ) => Effect<R, E, MO.ParsedShapeOf<Extr<MO.GetResponse<TModule>>>>
+) => {
+  h: typeof h
+  Request: MO.GetRequest<TModule>
+  Response: MO.GetResponse<TModule>
+  ResponseOpenApi: any
+} {
+  // TODO: Prevent over providing // no strict/shrink yet.
+  const Request = MO.extractRequest(_)
+  const Response = MO.extractResponse(_)
+
+  return <R, E>(
+    h: (
+      r: InstanceType<
+        MO.GetRequest<TModule> extends { new(...args: any[]): any } ? MO.GetRequest<TModule>
+          : never
+      >
+    ) => Effect<R, E, MO.ParsedShapeOf<Extr<MO.GetResponse<TModule>>>>
+  ) => ({
+    adaptResponse,
+    h,
+    Request,
+    Response,
+    ResponseOpenApi: _.ResponseOpenApi ?? Response
+  } as any)
+}
+
+type Extr<T> = T extends { Model: MO.SchemaAny } ? T["Model"]
+  : T extends MO.SchemaAny ? T
+  : never
+
+export function accessM_<T, UserId, Err>(
+  canAccess: (rsc: T, userId: UserId) => boolean,
+  bad: (rsc: T, userId: UserId) => Err
+) {
+  return <R, E, A>(
+    rsc: T,
+    userId: UserId,
+    ok: (rsc: T) => Effect<R, E, A>
+  ): Effect<R, E | Err, A> => {
+    if (canAccess(rsc, userId)) {
+      return ok(rsc)
+    }
+    return Effect.fail(bad(rsc, userId))
+  }
+}
+
+export function access_<T, UserId, Err>(
+  canAccess: (rsc: T, userId: UserId) => boolean,
+  bad: (rsc: T, userId: UserId) => Err
+) {
+  const auth = accessM_(canAccess, bad)
+  return <A>(rsc: T, userId: UserId, ok: (rsc: T) => A) => auth(rsc, userId, flow(ok, Effect.succeed))
+}
+
+export function accessM<T, UserId, Err>(
+  canAccess: (rsc: T, userId: UserId) => boolean,
+  bad: (rsc: T, userId: UserId) => Err
+) {
+  return <R, E, A>(userId: UserId, ok: (rsc: T) => Effect<R, E, A>) =>
+    (rsc: T): Effect<R, E | Err, A> => {
+      if (canAccess(rsc, userId)) {
+        return ok(rsc)
+      }
+      return Effect.fail(bad(rsc, userId))
+    }
+}
+
+export function access<T, UserId, Err>(
+  canAccess: (rsc: T, userId: UserId) => boolean,
+  bad: (rsc: T, userId: UserId) => Err
+) {
+  const auth = accessM(canAccess, bad)
+  return <A>(userId: UserId, ok: (rsc: T) => A) => auth(userId, flow(ok, Effect.succeed))
+}
+
+export function makeAuthorize<T, UserId>(
+  canAccess: (rsc: T, userId: UserId) => boolean,
+  type: string,
+  getId: (t: T) => string | number
+) {
+  return {
+    access_: access_(canAccess, () => new UnauthorizedError()),
+    access: access(canAccess, () => new UnauthorizedError()),
+    accessM_: accessM_(canAccess, () => new UnauthorizedError()),
+    accessM: accessM(canAccess, () => new UnauthorizedError()),
+
+    accessOrHide_: access_(
+      canAccess,
+      r => new NotFoundError(type, getId(r).toString())
+    ),
+    accessOrHide: access(
+      canAccess,
+      r => new NotFoundError(type, getId(r).toString())
+    ),
+    accessOrHideM_: accessM_(
+      canAccess,
+      r => new NotFoundError(type, getId(r).toString())
+    ),
+    accessOrHideM: accessM(
+      canAccess,
+      r => new NotFoundError(type, getId(r).toString())
+    )
+  }
+}

package/_src/{lib/api → api}/authorization.jwt.ts

@@ -1,5 +1,5 @@
 // import { configM, UserSVC } from "@/services.js"
-import * as Ex from "@effect-app/infra-adapters/express/index"
+import * as Ex from "@effect-app/infra-adapters/express"
 import { expressjwt } from "express-jwt"
 import jwtAuthz from "express-jwt-authz"
 import jwksRsa from "jwks-rsa"

package/_src/api/codec.ts

@@ -0,0 +1,27 @@
+import * as MO from "@effect-app/schema"
+import { Encoder, Parser } from "@effect-app/schema"
+import type { ParserEnv } from "@effect-app/schema/custom/Parser"
+
+export function makeCodec<
+  ParsedShape extends { id: Id },
+  ConstructorInput,
+  Encoded,
+  Api,
+  Id
+>(self: MO.Schema<unknown, ParsedShape, ConstructorInput, Encoded, Api>) {
+  const parse = MO.condemnDie(Parser.for(self))
+  // TODO: strict
+  const decode = (e: Encoded, env?: ParserEnv) => parse(e, env)
+  const enc = Encoder.for(self)
+
+  const encode = (u: ParsedShape) => Effect(() => enc(u))
+  const encodeToMap = toMap(encode)
+  return [decode, encode, encodeToMap] as const
+}
+
+function toMap<E, A extends { id: Id }, Id>(encode: (a: A) => Effect<never, never, E>) {
+  return (a: ReadonlyArray<A>) =>
+    a.map(task => Effect.tuple(Effect(task.id as A["id"]), encode(task)))
+      .collectAll()
+      .map(_ => new Map(_))
+}

package/_src/{lib/api → api}/defaultErrorHandler.ts

@@ -6,7 +6,7 @@ import type {
   OptimisticConcurrencyException,
   UnauthorizedError,
   ValidationError
-} from "../../errors.js"
+} from "../errors.js"
 import type { RequestContext } from "../RequestContext.js"
 import { logRequestError } from "./reportError.js"
 

package/_src/api/errors.ts.bak

@@ -0,0 +1,20 @@
+export class NotFoundError {
+  public readonly _tag = "NotFoundError"
+  public readonly message: string
+  constructor(type: string, id: string) {
+    this.message = `Didn't find ${type}#${id}`
+  }
+}
+
+export class ValidationError {
+  public readonly _tag = "ValidationError"
+  constructor(public readonly errors: ReadonlyArray<unknown>) {}
+}
+
+export class NotLoggedInError {
+  public readonly _tag = "NotLoggedInError"
+}
+
+export class UnauthorizedError {
+  public readonly _tag = "UnauthorizedError"
+}

package/_src/api/express/makeJsonSchema.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as RS from "./schema/routing.js"
+
+type Methods = "GET" | "PUT" | "POST" | "PATCH" | "DELETE"
+
+const rx = /:(\w+)/g
+
+type _A<C> = C extends Chunk<infer A> ? A : never
+
+/**
+ * Work in progress JSONSchema generator.
+ */
+export function makeJsonSchema(r: Iterable<RS.RouteDescriptorAny>) {
+  return Chunk.fromIterable(r)
+    .forEachEffect(RS.makeFromSchema)
+    .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(
+        {} as Record<string, Record<Methods, ReturnType<typeof map>>>,
+        (prev, e) => {
+          const path = e.path.split("?")[0].replace(rx, (_a, b) => `{${b}}`)
+          prev[path] = {
+            ...prev[path],
+            ...map(e) as any
+          }
+          return prev
+        }
+      )
+    })
+}
+
+class Response {
+  constructor(
+    public readonly statusCode: number,
+    public readonly type: any // string | JSONSchema | SubSchema
+  ) {}
+}

package/_src/api/express/makeOpenApiSpecs.ts

@@ -0,0 +1,60 @@
+/* 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 withRef = Effect.provideService(References)({ ref })
+    const paths = yield* $(pipe(makeJsonSchema(rdescs), withRef))
+    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
+      // test,
+    }
+  })
+}