@effect-app/infra 3.9.0 → 4.0.0-beta.0

package/src/CUPS.ts

@@ -1,6 +1,6 @@
 import { type FileOptions, tempFile } from "@effect-app/infra/fileUtil"
 import cp from "child_process"
-import { Config, Effect, Layer, Predicate, S } from "effect-app"
+import { Config, Effect, Layer, Option, Predicate, S, ServiceMap } from "effect-app"
 import { pretty } from "effect-app/utils"
 import fs from "fs"
 import os from "os"
@@ -79,7 +79,7 @@ function getAvailablePrinters(host?: string) {
     const { stdout } = yield* exec(["lpstat", ...buildListArgs({ host }), "-s"].join(" "))
     return [...stdout.matchAll(/device for (\w+):/g)]
       .map((_) => _[1])
-      .filter(Predicate.isNotNullable)
+      .filter(Predicate.isNotNullish)
       .map((_) => S.NonEmptyString255(_))
   })
 }
@@ -100,13 +100,14 @@ export const CUPSConfig = Config.all({
     )
 })
 
-export class CUPS extends Effect.Service<CUPS>()("effect-app/CUPS", {
-  effect: Effect.gen(function*() {
+export class CUPS extends ServiceMap.Service<CUPS>()("effect-app/CUPS", {
+  make: Effect.gen(function*() {
     const config = yield* CUPSConfig
+    const serverUrl = Option.getOrUndefined(config.server)
     function print(buffer: ArrayBuffer, printerId: PrinterId, ...options: string[]) {
       const _print = printBuffer({
         id: printerId,
-        url: config.server.value
+        url: serverUrl
       }, options)
       return _print(buffer)
     }
@@ -115,21 +116,21 @@ export class CUPS extends Effect.Service<CUPS>()("effect-app/CUPS", {
       printFile: (filePath: string, printerId: PrinterId, ...options: string[]) =>
         printFile({
           id: printerId,
-          url: config.server.value
+          url: serverUrl
         }, options)(filePath),
-      getAvailablePrinters: getAvailablePrinters(config.server.value?.host)
+      getAvailablePrinters: getAvailablePrinters(serverUrl?.host)
     }
   })
 }) {
   static readonly Fake = Layer.effect(
     this,
-    Effect.sync(() => {
-      return this.make({
-        print: (buffer, printerId, ...options) =>
+    Effect.sync(() =>
+      CUPS.of({
+        print: (buffer: ArrayBuffer, printerId: PrinterId, ...options: string[]) =>
           InfraLogger
             .logInfo("Printing to fake printer")
             .pipe(
-              Effect.zipRight(Effect.sync(() => ({ stdout: "fake", stderr: "" }))),
+              Effect.andThen(Effect.sync(() => ({ stdout: "fake", stderr: "" }))),
               Effect
                 .annotateLogs({
                   printerId,
@@ -137,11 +138,11 @@ export class CUPS extends Effect.Service<CUPS>()("effect-app/CUPS", {
                   "bufferSize": buffer.byteLength.toString()
                 })
             ),
-        printFile: (filePath, printerId, ...options) =>
+        printFile: (filePath: string, printerId: PrinterId, ...options: string[]) =>
           InfraLogger
             .logInfo("Printing to fake printer")
             .pipe(
-              Effect.zipRight(Effect.sync(() => ({ stdout: "fake", stderr: "" }))),
+              Effect.andThen(Effect.sync(() => ({ stdout: "fake", stderr: "" }))),
               Effect
                 .annotateLogs({
                   printerId,
@@ -151,6 +152,6 @@ export class CUPS extends Effect.Service<CUPS>()("effect-app/CUPS", {
             ),
         getAvailablePrinters: Effect.sync(() => [])
       })
-    })
+    )
   )
 }

package/src/Emailer/Sendgrid.ts

@@ -31,18 +31,18 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
         yield* InfraLogger.logDebug("Sending email").pipe(Effect.annotateLogs("msg", inspect(renderedMsg, false, 5)))
 
         const ret = yield* Effect
-          .async<
+          .callback<
             [sgMail.ClientResponse, Record<string, unknown>],
             Error | sgMail.ResponseError
           >(
-            (cb) =>
+            (resume) =>
               void sgMail.send(
                 renderedMsg as any, // sue me
                 msg.isMultiple ?? true,
                 (err, result) =>
                   err
-                    ? cb(Effect.fail(err))
-                    : cb(Effect.sync(() => result))
+                    ? resume(Effect.fail(err))
+                    : resume(Effect.sync(() => result!))
               )
           )
           .pipe(Effect.mapError((raw) => new SendMailError({ raw })))
@@ -107,26 +107,28 @@ function renderFake(addr: EmailData | readonly EmailData[], makeId: () => number
   }
 }
 const eq = Equivalence.mapInput(
-  Equivalence.string,
+  Equivalence.String,
   (to: { name?: string; email: string } | string) => typeof to === "string" ? to.toLowerCase() : to.email.toLowerCase()
 )
 
+function isEmailDataArray(md: EmailData | readonly EmailData[]): md is readonly EmailData[] {
+  return globalThis.Array.isArray(md)
+}
+
 // TODO: should just not add any already added email address
 // https://stackoverflow.com/a/53603076/11595834
 function renderFakeIfTest(addr: EmailData | readonly EmailData[], makeId: () => number) {
-  return Array.isArray(addr)
-    ? Array.dedupeWith(
-      addr
-        .map((x) => (isTestAddress(x) ? renderFake(x, makeId) : x)),
+  if (isEmailDataArray(addr)) {
+    return Array.dedupeWith(
+      addr.map((x) => (isTestAddress(x) ? renderFake(x, makeId) : x)),
       eq
     )
-    : isTestAddress(addr)
-    ? renderFake(addr, makeId)
-    : addr
+  }
+  return isTestAddress(addr) ? renderFake(addr, makeId) : addr
 }
 
 function renderMailData(md: EmailData | readonly EmailData[]): string {
-  if (Array.isArray(md)) {
+  if (isEmailDataArray(md)) {
     return md.map(renderMailData).join(", ")
   }
   if (typeof md === "string") {

package/src/Emailer/service.ts

@@ -1,15 +1,15 @@
 import type { MailContent, MailData } from "@sendgrid/helpers/classes/mail.js"
 import type { ResponseError } from "@sendgrid/mail"
-import { Context, Data, type Effect, type NonEmptyReadonlyArray, type Redacted } from "effect-app"
+import { Data, type Effect, type NonEmptyReadonlyArray, type Redacted, ServiceMap } from "effect-app"
 import type { Email } from "effect-app/Schema"
 
 export class SendMailError extends Data.TaggedError("SendMailError")<{
   readonly raw: Error | ResponseError
 }> {}
 
-export class Emailer extends Context.TagId("effect-app/Emailer")<Emailer, {
+export class Emailer extends ServiceMap.Opaque<Emailer, {
   sendMail: (msg: EmailMsgOptionalFrom) => Effect.Effect<void, SendMailError>
-}>() {}
+}>()("effect-app/Emailer") {}
 
 export type EmailData = Email | {
   name?: string

package/src/MainFiberSet.ts

@@ -1,16 +1,15 @@
-import { Context, Effect, Fiber, FiberSet, Layer } from "effect-app"
+import { Effect, Fiber, FiberSet, Layer, ServiceMap } from "effect-app"
 import type {} from "effect/Scope"
-import type {} from "effect/Context"
 import { InfraLogger } from "./logger.js"
 import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.js"
 import { setRootParentSpan } from "./RequestFiberSet.js"
 
 const make = Effect.gen(function*() {
   const set = yield* FiberSet.make<unknown, never>()
-  const add = (...fibers: Fiber.RuntimeFiber<never, never>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.unsafeAdd(set, _)))
-  const addAll = (fibers: readonly Fiber.RuntimeFiber<never, never>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.unsafeAdd(set, _)))
+  const add = (...fibers: Fiber.Fiber<never, never>[]) =>
+    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
+  const addAll = (fibers: readonly Fiber.Fiber<never, never>[]) =>
+    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
   const join = FiberSet.size(set).pipe(
     Effect.andThen((count) => InfraLogger.logDebug(`Joining ${count} current fibers on the MainFiberSet`)),
     Effect.andThen(FiberSet.join(set))
@@ -42,7 +41,7 @@ const make = Effect.gen(function*() {
   function forkDaemonReport<A, E, R>(self: Effect.Effect<A, E, R>) {
     return self.pipe(
       Effect.asVoid,
-      Effect.catchAllCause(reportNonInterruptedFailureCause({})),
+      Effect.catchCause(reportNonInterruptedFailureCause({})),
       setRootParentSpan,
       Effect.uninterruptible,
       run
@@ -63,10 +62,15 @@ const make = Effect.gen(function*() {
  * you should register these long running fibers in a FiberSet, and join them at the end of your main program.
  * This way any errors will blow up the main program instead of fibers dying unknowingly.
  */
-export class MainFiberSet extends Context.TagMakeId("MainFiberSet", make)<MainFiberSet>() {
-  static readonly Live = this.toLayerScoped()
-  static readonly JoinLive = this.pipe(Effect.andThen((_) => _.join), Layer.effectDiscard, Layer.provide(this.Live))
-  static readonly run = <A, R>(self: Effect.Effect<A, never, R>) => this.use((_) => _.run(self))
+export class MainFiberSet extends ServiceMap.Service<MainFiberSet>()("MainFiberSet", { make }) {
+  static readonly Live = Layer.effect(this, this.make)
+  static readonly JoinLive = this.asEffect().pipe(
+    Effect.andThen((_) => _.join),
+    Layer.effectDiscard,
+    Layer.provide(this.Live)
+  )
+  static readonly run = <A, R>(self: Effect.Effect<A, never, R>) =>
+    this.asEffect().pipe(Effect.andThen((_) => _.run(self)))
   static readonly forkDaemonReport = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    this.use((_) => _.forkDaemonReport(self))
+    this.asEffect().pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
 }

package/src/Model/Repository/ext.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { Array, Effect, Exit, type NonEmptyArray, type NonEmptyReadonlyArray, Option, Request, RequestResolver } from "effect-app"
+import { Array, Effect, Exit, type NonEmptyArray, Option, Request, RequestResolver } from "effect-app"
 import { type InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "effect-app/client/errors"
 import { type FixEnv, type PureEnv, runTerm } from "effect-app/Pure"
 import { AnyPureDSL } from "../dsl.js"
@@ -21,9 +21,11 @@ export const extendRepo = <
   repo: Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish>
 ) => {
   const get = (id: T[IdKey]) =>
-    Effect.flatMap(
-      repo.find(id),
-      (_) => Effect.mapError(_, () => new NotFoundError<ItemType>({ type: repo.itemType, id }))
+    repo.find(id).pipe(
+      Effect.flatMap(Option.match({
+        onNone: () => Effect.fail(new NotFoundError<ItemType>({ type: repo.itemType, id })),
+        onSome: Effect.succeed
+      }))
     )
   function saveManyWithPure_<
     R,
@@ -80,7 +82,7 @@ export const extendRepo = <
     batchSize = 100
   ) {
     return Effect.forEach(
-      Array.chunk_(items, batchSize),
+      Array.chunksOf(items, batchSize),
       (batch) =>
         saveAllWithEffectInt(
           runTerm(pure, batch)
@@ -176,7 +178,7 @@ export const extendRepo = <
   } = (items, pure, batch?: "batched" | number) =>
     batch
       ? Effect.forEach(
-        Array.chunk_(items, batch === "batched" ? 100 : batch),
+        Array.chunksOf(items, batch === "batched" ? 100 : batch),
         (batch) =>
           saveAllWithEffectInt(
             runTerm(pure, batch)
@@ -207,30 +209,30 @@ export const extendRepo = <
   const _request = Request.tagged<Req>(`Get${repo.itemType}`)
 
   const requestResolver = RequestResolver
-    .makeBatched((
-      requests: NonEmptyReadonlyArray<Req>
+    .make((
+      entries: NonEmptyArray<Request.Entry<Req>>,
+      _key: unknown
     ) =>
-      (repo.query(Q.where(repo.idKey as any, "in" as any, requests.map((_) => _.id)) as any) as Effect.Effect<
+      (repo.query(Q.where(repo.idKey as any, "in" as any, entries.map((_) => _.request.id)) as any) as Effect.Effect<
         readonly T[],
         never
       >)
         // TODO
         .pipe(
           Effect.andThen((items) =>
-            Effect.forEach(requests, (r) =>
+            Effect.forEach(entries, (entry) =>
               Request.complete(
-                r,
                 Array
-                  .findFirst(items, (_) => _[repo.idKey] === r.id)
+                  .findFirst(items, (_) => _[repo.idKey] === entry.request.id)
                   .pipe(Option.match({
-                    onNone: () => Exit.fail(new NotFoundError({ type: repo.itemType, id: r.id })),
+                    onNone: () => Exit.fail(new NotFoundError({ type: repo.itemType, id: entry.request.id })),
                     onSome: Exit.succeed
                   }))
-              ), { discard: true })
+              )(entry), { discard: true })
           ),
           Effect
-            .catchAllCause((cause) =>
-              Effect.forEach(requests, Request.complete(Exit.failCause(cause)), { discard: true })
+            .catchCause((cause) =>
+              Effect.forEach(entries, (entry) => Request.complete(Exit.failCause(cause))(entry), { discard: true })
             )
         )
     )