Blog posts sample [Do not Merge]

.ncurc.json

@@ -8,6 +8,6 @@
     "@types/redis",
     "eslint-plugin-codegen",
     "vue-toastification",
-    "@sentry/*"
+    "@opentelemetry/*"
   ]
 }

README.md

@@ -1,4 +1,6 @@
-# @effect-app-boilerplate
+# Effect App Sample
+
+Demo basic usage of Models, Resources, Controllers, Clients, long running tasks and some SSE.
 
 ## Setup
 
@@ -30,21 +32,6 @@ Notes
 
 - Make sure you don't have the old Vue/Vetur vs code plugin installed, but the new ones only: "Vue.volar", "Vue.vscode-typescript-vue-plugin"
 
-### Helpful editor hints
-
-Add to keybinds:
-
-```json
-{
-    "key": "ctrl+shift+i",
-    "command": "editor.action.sourceAction",
-    "args": {
-        "kind": "source.addMissingImports",
-        "apply": "first"
-    }
-}
-```
-
 ## Framework documentation
 
 [WIP](https://github.com/effect-ts-app/docs)

api/src/Blog.controllers.ts

@@ -0,0 +1,86 @@
+import { Router } from "#lib/routing"
+import { BlogPost } from "#models/Blog"
+import { BlogRsc } from "#resources"
+import { BogusEvent } from "#resources/Events"
+import { BlogPostRepo, Events, Operations, UserRepo } from "#services"
+import { Duration, Effect, Schedule } from "effect"
+import { Option } from "effect-app"
+import { NonEmptyString2k, NonNegativeInt } from "effect-app/Schema"
+import { OperationsDefault } from "./lib/layers.js"
+
+export default Router(BlogRsc)({
+  dependencies: [
+    BlogPostRepo.Default,
+    UserRepo.Default,
+    OperationsDefault,
+    Events.Default
+  ],
+  *effect(match) {
+    const blogPostRepo = yield* BlogPostRepo
+    const userRepo = yield* UserRepo
+    const events = yield* Events
+    const operations = yield* Operations
+
+    return match({
+      FindPost: (req) =>
+        blogPostRepo
+          .find(req.id)
+          .pipe(Effect.andThen(Option.getOrNull)),
+      GetPosts: blogPostRepo
+        .all
+        .pipe(Effect.andThen((items) => ({ items }))),
+      CreatePost: (req) =>
+        userRepo
+          .getCurrentUser
+          .pipe(
+            Effect.andThen((author) => (new BlogPost({ ...req, author }, true))),
+            Effect.tap(blogPostRepo.save)
+          ),
+      *PublishPost(req) {
+        const post = yield* blogPostRepo.get(req.id)
+
+        console.log("publishing post", post)
+
+        const targets = [
+          "google",
+          "twitter",
+          "facebook"
+        ]
+
+        const done: string[] = []
+
+        const op = yield* operations.fork(
+          (opId) =>
+            operations
+              .update(opId, {
+                total: NonNegativeInt(targets.length),
+                completed: NonNegativeInt(done.length)
+              })
+              .pipe(
+                Effect.andThen(Effect.forEach(targets, (_) =>
+                  Effect
+                    .sync(() => done.push(_))
+                    .pipe(
+                      Effect.tap(() =>
+                        operations.update(opId, {
+                          total: NonNegativeInt(targets.length),
+                          completed: NonNegativeInt(done.length)
+                        })
+                      ),
+                      Effect.delay(Duration.seconds(4))
+                    ))),
+                Effect.andThen(() => "the answer to the universe is 41")
+              ),
+          // while operation is running...
+          (_opId) =>
+            Effect
+              .suspend(() => events.publish(new BogusEvent()))
+              .pipe(Effect.schedule(Schedule.spaced(Duration.seconds(1)))),
+          NonEmptyString2k("post publishing")
+        )
+
+        return op.id
+      }
+    })
+  }
+})

api/src/HelloWorld.controllers.ts

@@ -15,22 +15,21 @@ export default Router(HelloWorldRsc)({
     return match({
       *GetHelloWorld({ echo }) {
         const context = yield* getRequestContext
-        return yield* userRepo
+        const user = yield* userRepo
           .tryGetCurrentUser
           .pipe(
             Effect.catchTags({
               "NotLoggedInError": () => Effect.succeed(null),
               "NotFoundError": () => Effect.succeed(null)
-            }),
-            Effect.andThen((user) =>
-              new GetHelloWorld.success({
-                context,
-                echo,
-                currentUser: user,
-                randomUser: generate(S.A.make(User)).value
-              })
-            )
+            })
           )
+
+        return new GetHelloWorld.success({
+          context,
+          echo,
+          currentUser: user,
+          randomUser: generate(S.A.make(User)).value
+        })
       }
     })
   }

api/src/Users.controllers.ts

@@ -0,0 +1,22 @@
+import { Router } from "#lib/routing"
+import { UsersRsc } from "#resources"
+import type { UserView } from "#resources/views"
+import { Q, UserRepo } from "#services"
+import { Array } from "effect"
+import { Effect, Order } from "effect-app"
+
+export default Router(UsersRsc)({
+  dependencies: [UserRepo.Default],
+  *effect(match) {
+    const userRepo = yield* UserRepo
+
+    return match({
+      IndexUsers: (req) =>
+        userRepo
+          .query(Q.where("id", "in", req.filterByIds))
+          .pipe(Effect.andThen((users) => ({
+            users: Array.sort(users, Order.mapInput(Order.string, (_: UserView) => _.displayName))
+          })))
+    })
+  }
+})

api/src/controllers.ts

@@ -1,7 +1,9 @@
 // codegen:start {preset: barrel, include: ./*.controllers.ts, import: default}
 import accountsControllers from "./Accounts.controllers.js"
+import blogControllers from "./Blog.controllers.js"
 import helloWorldControllers from "./HelloWorld.controllers.js"
 import operationsControllers from "./Operations.controllers.js"
+import usersControllers from "./Users.controllers.js"
 
-export { accountsControllers, helloWorldControllers, operationsControllers }
+export { accountsControllers, blogControllers, helloWorldControllers, operationsControllers, usersControllers }
 // codegen:end

api/src/models/Blog.ts

@@ -0,0 +1,26 @@
+import { S } from "effect-app"
+import { UserFromId } from "./User.js"
+
+export const BlogPostId = S.prefixedStringId<BlogPostId>()("post", "BlogPostId")
+export interface BlogPostIdBrand {
+  readonly BlogPostId: unique symbol
+}
+export type BlogPostId = S.StringId & BlogPostIdBrand & `post-${string}`
+
+export class BlogPost extends S.ExtendedClass<BlogPost, BlogPost.Encoded>()({
+  id: BlogPostId.withDefault,
+  title: S.NonEmptyString255,
+  body: S.NonEmptyString2k,
+  createdAt: S.Date.withDefault,
+  author: S.propertySignature(UserFromId).pipe(S.fromKey("authorId"))
+}) {}
+
+// codegen:start {preset: model}
+//
+/* eslint-disable */
+export namespace BlogPost {
+  export interface Encoded extends S.Struct.Encoded<typeof BlogPost["fields"]> {}
+}
+/* eslint-enable */
+//
+// codegen:end

api/src/resources.ts

@@ -4,6 +4,8 @@ export { ClientEvents } from "./resources/Events.js"
 
 // codegen:start {preset: barrel, include: ./resources/*.ts, exclude: [./resources/index.ts, ./resources/lib.ts, ./resources/integrationEvents.ts, ./resources/Messages.ts, ./resources/views.ts, ./resources/Events.ts], export: { as: 'PascalCase', postfix: 'Rsc' }}
 export * as AccountsRsc from "./resources/Accounts.js"
+export * as BlogRsc from "./resources/Blog.js"
 export * as HelloWorldRsc from "./resources/HelloWorld.js"
 export * as OperationsRsc from "./resources/Operations.js"
+export * as UsersRsc from "./resources/Users.js"
 // codegen:end

api/src/resources/Blog.ts

@@ -0,0 +1,31 @@
+import { BlogPost, BlogPostId } from "#models/Blog"
+import { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "effect-app/client"
+import { OperationId } from "effect-app/Operations"
+import { S } from "./lib.js"
+import { BlogPostView } from "./views.js"
+
+export class CreatePost extends S.Req<CreatePost>()("CreatePost", BlogPost.pick("title", "body"), {
+  allowRoles: ["user"],
+  success: S.Struct({ id: BlogPostId }),
+  failure: S.Union(NotFoundError, InvalidStateError, OptimisticConcurrencyException)
+}) {}
+
+export class FindPost extends S.Req<FindPost>()("FindPost", {
+  id: BlogPostId
+}, { allowAnonymous: true, allowRoles: ["user"], success: S.NullOr(BlogPostView) }) {}
+
+export class GetPosts extends S.Req<GetPosts>()("GetPosts", {}, {
+  allowAnonymous: true,
+  allowRoles: ["user"],
+  success: S.Struct({
+    items: S.Array(BlogPostView)
+  })
+}) {}
+
+export class PublishPost extends S.Req<PublishPost>()("PublishPost", {
+  id: BlogPostId
+}, { allowRoles: ["user"], success: OperationId, failure: S.Union(NotFoundError) }) {}
+
+// codegen:start {preset: meta, sourcePrefix: src/resources/}
+export const meta = { moduleName: "Blog" } as const
+// codegen:end

api/src/resources/Users.ts

@@ -0,0 +1,17 @@
+import { UserId } from "#models/User"
+import { S } from "./lib.js"
+import { UserView } from "./views/UserView.js"
+
+export class IndexUsers extends S.Req<IndexUsers>()("IndexUsers", {
+  filterByIds: S.NonEmptyArray(UserId)
+}, {
+  allowAnonymous: true,
+  allowRoles: ["user"],
+  success: S.Struct({
+    users: S.Array(UserView)
+  })
+}) {}
+
+// codegen:start {preset: meta, sourcePrefix: src/resources/}
+export const meta = { moduleName: "Users" } as const
+// codegen:end

api/src/resources/resolvers/UserResolver.ts

@@ -0,0 +1,53 @@
+import { UserId } from "#models/User"
+import { clientFor } from "#resources/lib"
+import { Effect, Exit, Request, RequestResolver } from "effect"
+import { Array, Option, pipe, S } from "effect-app"
+import { ApiClientFactory, NotFoundError } from "effect-app/client"
+import { type Schema } from "effect-app/Schema"
+import * as UsersRsc from "../Users.js"
+import { UserView } from "../views/UserView.js"
+
+interface GetUserViewById extends Request.Request<UserView, NotFoundError<"User">> {
+  readonly _tag: "GetUserViewById"
+  readonly id: UserId
+}
+const GetUserViewById = Request.tagged<GetUserViewById>("GetUserViewById")
+
+const getUserViewByIdResolver = RequestResolver
+  .makeBatched((requests: GetUserViewById[]) =>
+    clientFor(UsersRsc).pipe(
+      Effect.flatMap((client) =>
+        client
+          .IndexUsers
+          .handler({ filterByIds: pipe(requests.map((_) => _.id), Array.toNonEmptyArray, Option.getOrUndefined)! })
+      ),
+      Effect.andThen(({ users }) =>
+        Effect.forEach(requests, (r) =>
+          Request.complete(
+            r,
+            Array
+              .findFirst(users, (_) => _.id === r.id ? Option.some(Exit.succeed(_)) : Option.none())
+              .pipe(Option.getOrElse(() => Exit.fail(new NotFoundError({ type: "User", id: r.id }))))
+          ), { discard: true })
+      ),
+      Effect.orDie,
+      Effect.catchAllCause((cause) =>
+        Effect.forEach(
+          requests,
+          (request) => Request.failCause(request, cause),
+          { discard: true }
+        )
+      )
+    )
+  )
+  .pipe(RequestResolver.batchN(25), RequestResolver.contextFromServices(ApiClientFactory))
+
+// TODO: How to globally cache - right now we had to move the RequestCache from the runtime to clientFor
+export const UserViewFromId: Schema<UserView, string, ApiClientFactory> = S.transformOrFail(
+  UserId,
+  S.typeSchema(UserView),
+  {
+    decode: (id) => Effect.request(GetUserViewById({ id }), getUserViewByIdResolver).pipe(Effect.orDie),
+    encode: (u) => Effect.succeed(u.id)
+  }
+)

api/src/resources/views.ts

@@ -1,3 +1,4 @@
 // codegen:start {preset: barrel, include: ./views/*.ts}
+export * from "./views/PostView.js"
 export * from "./views/UserView.js"
 // codegen:end

api/src/resources/views/PostView.ts

@@ -0,0 +1,18 @@
+import { BlogPost } from "#models/Blog"
+import { S } from "#resources/lib"
+import { UserViewFromId } from "../resolvers/UserResolver.js"
+
+export class BlogPostView extends S.ExtendedClass<BlogPostView, BlogPostView.Encoded>()({
+  ...BlogPost.omit("author"),
+  author: S.propertySignature(UserViewFromId).pipe(S.fromKey("authorId"))
+}) {}
+
+// codegen:start {preset: model}
+//
+/* eslint-disable */
+export namespace BlogPostView {
+  export interface Encoded extends S.Struct.Encoded<typeof BlogPostView["fields"]> {}
+}
+/* eslint-enable */
+//
+// codegen:end

api/src/router.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as MW from "#lib/middleware"
+import { Events } from "#services"
 import { Router } from "@effect-app/infra/api/routing"
 import { reportError } from "@effect-app/infra/errorReporter"
 import { RpcSerialization } from "@effect/rpc"
 import { FiberRef, flow } from "effect"
 import { Console, Effect, Layer } from "effect-app"
 import { HttpMiddleware, HttpRouter, HttpServer } from "effect-app/http"
 import { BaseConfig, MergedConfig } from "./config.js"
-import { Events } from "./services.js"
 
 const prodOrigins: string[] = []
 const demoOrigins: string[] = []

api/src/services/DBContext.ts

@@ -1,3 +1,4 @@
 // codegen:start {preset: barrel, include: ./DBContext/* }
+export * from "./DBContext/BlogPostRepo.js"
 export * from "./DBContext/UserRepo.js"
 // codegen:end