@effect-app/infra 0.7.0

package/_src/lib/rateLimit.ts

@@ -0,0 +1,126 @@
+/**
+ * Executes the specified effect, acquiring the specified number of permits
+ * immediately before the effect begins execution and releasing them
+ * delayed by duration after the effect completes execution, whether by success,
+ * failure, or interruption.
+ *
+ * @tsplus static effect/stm/TSemaphore.Ops withPermitsDuration
+ * @tsplus pipeable effect/stm/TSemaphore withPermitsDuration
+ */
+export function withPermitsDuration(permits: number, duration: DUR) {
+  return (self: TSemaphore): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A> => {
+    return effect =>
+      Effect.uninterruptibleMask(
+        restore =>
+          restore(self.acquireN(permits).commit)
+            > restore(effect)
+              .ensuring(
+                self.releaseN(permits)
+                  .commit
+                  .delay(duration)
+              )
+      )
+  }
+}
+
+/**
+ * Executes the specified effect, acquiring the specified number of permits
+ * immediately before the effect begins execution and releasing them
+ * delayed by duration after the effect completes execution, whether by success,
+ * failure, or interruption.
+ *
+ * @tsplus static effect/io/Effect/Semaphore.Ops withPermitsDuration
+ * @tsplus pipeable effect/io/Effect/Semaphore withPermitsDuration
+ */
+export function SEM_withPermitsDuration(permits: number, duration: DUR) {
+  return (self: Semaphore): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A> => {
+    return effect =>
+      Effect.uninterruptibleMask(
+        restore =>
+          restore(self.take(permits))
+            > restore(effect)
+              .ensuring(
+                self.release(permits)
+                  .delay(duration)
+              )
+      )
+  }
+}
+
+/**
+ * @tsplus pipeable Iterable batchNPar
+ * @tsplus static Collection.Aspects batchNPar
+ */
+export function batchNPar<R, E, A, R2, E2, A2, T>(
+  n: number,
+  forEachItem: (item: T, iWithinBatch: number, i: number) => Effect<R, E, A>,
+  forEachBatch: (a: Chunk<A>, i: number) => Effect<R2, E2, A2>
+) {
+  return (items: Iterable<T>) =>
+    items.chunk(n)
+      .forEachEffectParWithIndex((_, i) =>
+        _.forEachParWithIndex((_, j) => forEachItem(_, j, i))
+          .flatMap(_ => forEachBatch(_, i))
+      )
+}
+
+/**
+ * @tsplus pipeable Iterable batch
+ * @tsplus static Collection.Aspects batch
+ */
+export function batch<R, E, A, R2, E2, A2, T>(
+  n: number,
+  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<R, E, A>,
+  forEachBatch: (a: Chunk<A>, i: number) => Effect<R2, E2, A2>
+) {
+  return (items: Iterable<T>) =>
+    items.chunk(n)
+      .forEachEffectWithIndex((_, i) =>
+        _.forEachParWithIndex((_, j) => forEachItem(_, j, i))
+          .flatMap(_ => forEachBatch(_, i))
+      )
+}
+
+// /**
+//  * @tsplus pipeable Iterable rateLimit
+//  * @tsplus static Collection.Aspects rateLimit
+//  */
+// export function rateLimit(
+//   n: number,
+//   d: DUR
+// ) {
+//   return <T>(items: Iterable<T>) =>
+//     <R, E, A, R2, E2, A2>(
+//       forEachItem: (i: T) => Effect<R, E, A>,
+//       forEachBatch: (a: Chunk<A>) => Effect<R2, E2, A2>
+//     ) =>
+//       Stream.fromCollection(items)
+//         .rechunk(n)
+//         .throttleShape(n, d, () => n)
+//         .mapChunksEffect(_ => _.forEachEffectPar(forEachItem).tap(forEachBatch))
+//         .runCollect
+// }
+
+/**
+ * @tsplus pipeable Iterable naiveRateLimit
+ * @tsplus static Collection.Aspects naiveRateLimit
+ */
+
+export function naiveRateLimit(
+  n: number,
+  d: DUR
+) {
+  return <T>(items: Iterable<T>) => (<R, E, A, R2, E2, A2>(
+    forEachItem: (i: T) => Effect<R, E, A>,
+    forEachBatch: (a: Chunk<A>) => Effect<R2, E2, A2>
+  ) =>
+    items.chunk(n)
+      .forEachEffectWithIndex((batch, i) =>
+        ((i === 0) ? Effect.unit : Effect.unit.delay(d))
+          .zipRight(
+            batch.forEachEffectPar(forEachItem)
+              .withParallelism(n)
+              .flatMap(forEachBatch)
+          )
+      ))
+}

package/_src/services/CUPS/service.ts

@@ -0,0 +1,16 @@
+export const PrinterId = ReasonableString
+export type PrinterId = ReasonableString
+
+export interface CUPS {
+  print: (buffer: ArrayBuffer, printerId: PrinterId, ...options: string[]) => Effect<never, unknown, {
+    stdout: string
+    stderr: string
+  }>
+  getAvailablePrinters: Effect<never, unknown, ReasonableString[]>
+}
+
+/**
+ * @tsplus type CUPS.Ops
+ */
+export interface CUPSOps extends Tag<CUPS> {}
+export const CUPS: CUPSOps = Tag<CUPS>()

package/_src/services/CUPS.ts

@@ -0,0 +1,105 @@
+import cp from "child_process"
+import util from "util"
+import { tempFile } from "../lib/fileUtil.js"
+
+import { isTruthy } from "@effect-app/core/utils"
+import { ReasonableString } from "@effect-app/schema"
+import { Effect } from "@effect/io/Effect"
+import fs from "fs"
+import os from "os"
+import path from "path"
+import type { PrinterId } from "./CUPS/service.js"
+import { CUPS } from "./CUPS/service.js"
+
+export * from "./CUPS/service.js"
+
+/**
+ * @tsplus static CUPS.Ops Live
+ */
+export function LiveCUPS(cupsServer?: URL) {
+  return makeCUPS(cupsServer).toLayer(CUPS)
+}
+
+function makeCUPS(cupsServer?: URL) {
+  return Effect(() => {
+    function print_(buffer: ArrayBuffer, printerId: PrinterId, ...options: string[]) {
+      const print = printBuffer({
+        id: printerId,
+        url: cupsServer
+      }, options)
+      return print(buffer)
+    }
+    return {
+      print: print_,
+      getAvailablePrinters: getAvailablePrinters(cupsServer?.host)
+    }
+  })
+}
+
+const exec_ = util.promisify(cp.exec)
+const exec = (command: string) =>
+  Effect.logDebug(`Executing: ${command}`)
+    > Effect.tryPromise(() => exec_(command))
+      .tap(r => (Effect.logDebug(`Executed`).logAnnotate("result", r.$$.pretty)))
+type PrinterConfig = { url?: URL; id: string }
+
+function printFile(printer: PrinterConfig | undefined, options: string[]) {
+  return (filePath: string) => printFile_(filePath, printer, options)
+}
+
+function printFile_(filePath: string, printer: PrinterConfig | undefined, options: string[]) {
+  return exec(["lp", ...buildPrintArgs(filePath, printer, options)].join(" "))
+}
+
+function* buildPrintArgs(filePath: string, printer: PrinterConfig | undefined, options: string[]) {
+  if (printer) {
+    if (printer.url) {
+      yield `-h ${printer.url.host}`
+      if (printer.url.username) {
+        yield `-U ${printer.url.username}`
+      }
+    }
+    yield `-d "${printer.id}"`
+    for (const o of options) {
+      yield `-o ${o}`
+    }
+  }
+  yield `"${filePath}"`
+}
+
+export const prepareTempDir = Effect(() => {
+  // TODO
+  try {
+    fs.mkdirSync(path.join(os.tmpdir(), "effect-ts-app"))
+  } catch (err) {
+    if (`${err}`.includes("EEXIST")) {
+      return
+    }
+    throw err
+  }
+})
+
+const makeTempFile = tempFile("effect-ts-app")
+const makePrintJobTempFile = makeTempFile("print-job")
+
+function printBuffer(printer: PrinterConfig, options: string[]) {
+  return (buffer: ArrayBuffer) =>
+    makePrintJobTempFile(Buffer.from(buffer))
+      .flatMapScoped(printFile(printer, options))
+}
+
+function getAvailablePrinters(host?: string) {
+  return Do($ => {
+    const { stdout } = $(exec(["lpstat", ...buildListArgs({ host }), "-s"].join(" ")))
+    return [...stdout.matchAll(/device for (\w+):/g)]
+      .map(_ => _[1])
+      .filter(isTruthy)
+      .map(ReasonableString)
+  })
+}
+
+function* buildListArgs(config?: { host?: string }) {
+  if (config?.host) {
+    yield `-h ${config.host}`
+  }
+}

package/_src/services/Cache.ts

@@ -0,0 +1,45 @@
+import type { Cache as _Cache } from "../vendor/Cache/Cache.js"
+import { make as _make } from "../vendor/Cache/Cache.js"
+import type { CacheState } from "../vendor/Cache/Cache/_internal/CacheState.js"
+import type { Lookup } from "../vendor/Cache/Lookup.js"
+
+/**
+ * @tsplus type ets/cache/Cache
+ */
+export interface Cache<Key, Error, Value> extends _Cache<Key, Error, Value> {}
+
+/**
+ * @tsplus type ets/cache/CacheOps
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface CacheOps {}
+
+export const Cache: CacheOps = {}
+
+/**
+ * @tsplus static ets/cache/CacheOps make
+ */
+export function make<Key, Environment, Error, Value>(
+  capacity: number,
+  duration: DUR,
+  lookup: Lookup<Key, Environment, Error, Value>
+) {
+  return _make(capacity, duration, lookup) as Effect<Environment, never, Cache<Key, Error, Value>>
+}
+
+/**
+ * @tsplus getter ets/cache/Cache results
+ */
+export function results<Key, Error, Value>(
+  self: Cache<Key, Error, Value>
+): Effect<never, never, Chunk<[Key, Exit<Error, Value>]>> {
+  return Effect(() => {
+    const values: Array<[Key, Exit<Error, Value>]> = []
+    for (const [key, value] of ((self as any).cacheState as CacheState<Key, Error, Value>).map) {
+      if (value._tag === "Complete") {
+        values.push([key, value.exit])
+      }
+    }
+    return Chunk.fromIterable(values)
+  })
+}

package/_src/services/Emailer/Sendgrid.ts

@@ -0,0 +1,123 @@
+import type { EmailData } from "@sendgrid/helpers/classes/email-address.js"
+import sgMail from "@sendgrid/mail"
+import { inspect } from "util"
+import { Emailer } from "./service.js"
+import type { EmailMsg, EmailMsgOptionalFrom, SendgridConfig } from "./service.js"
+
+const makeLiveSendgrid = ({ apiKey, defaultFrom, realMail, subjectPrefix }: SendgridConfig) =>
+  Effect(() => {
+    sgMail.setApiKey(apiKey.value)
+
+    return {
+      sendMail(msg_: EmailMsgOptionalFrom) {
+        return Effect.gen(function*($) {
+          const msg = { ...msg_, from: msg_.from ?? defaultFrom }
+          const render = renderMessage(!realMail)
+
+          const renderedMsg_ = render(msg)
+          const renderedMsg = { ...renderedMsg_, subject: `${subjectPrefix}${renderedMsg_.subject}` }
+          yield* $(Effect.logDebug("Sending email").logAnnotate("msg", inspect(renderedMsg, false, 5)))
+
+          const ret = yield* $(
+            Effect.async<
+              never,
+              Error | sgMail.ResponseError,
+              [sgMail.ClientResponse, Record<string, unknown>]
+            >(
+              cb =>
+                void sgMail.send(renderedMsg, false, (err, result) =>
+                  err ?
+                    cb(Effect.fail(err)) :
+                    cb(Effect(result)))
+            )
+          )
+
+          // const event = {
+          //   name: "EmailSent",
+          //   properties: {
+          //     templateId: msg.templateId
+          //   }
+          // }
+          // yield* $(Effect.logDebug("Tracking email event").logAnnotate("event", event.$$.pretty))
+          // const { trackEvent } = yield* $(AiContextService.access)
+          // trackEvent(event)
+          return ret
+        })
+      }
+    }
+  })
+
+/**
+ * @tsplus static Emailer.Ops LiveSendgrid
+ */
+export function LiveSendgrid(config: Config<SendgridConfig>) {
+  return config.config
+    .flatMap(makeLiveSendgrid)
+    .toLayer(Emailer)
+}
+
+/**
+ * @hidden
+ */
+export function renderMessage(forceFake: boolean) {
+  let i = 0
+  const makeId = () => i++
+  return forceFake
+    ? (msg: EmailMsg) => ({
+      ...msg,
+      to: msg.to && renderFake(msg.to, makeId),
+      cc: msg.cc && renderFake(msg.cc, makeId),
+      bcc: msg.bcc && renderFake(msg.bcc, makeId)
+    })
+    : (msg: EmailMsg) => ({
+      ...msg,
+      to: msg.to && renderFakeIfTest(msg.to, makeId),
+      cc: msg.cc && renderFakeIfTest(msg.cc, makeId),
+      bcc: msg.bcc && renderFakeIfTest(msg.bcc, makeId)
+    })
+}
+
+/**
+ * @hidden
+ */
+export function isTestAddress(to: EmailData) {
+  return (
+    (typeof to === "string" && to.toLowerCase().endsWith(".test")) ||
+    (typeof to === "object" &&
+      "email" in to &&
+      to.email.toLowerCase().endsWith(".test"))
+  )
+}
+
+function renderFake(addr: EmailData | EmailData[], makeId: () => number) {
+  return {
+    name: renderMailData(addr),
+    email: `test+${makeId()}@nomizz.com`
+  }
+}
+const eq = Equal.string.contramap((to: { name?: string; email: string } | string) =>
+  typeof to === "string" ? to.toLowerCase() : to.email.toLowerCase()
+)
+
+// TODO: should just not add any already added email address
+// https://stackoverflow.com/a/53603076/11595834
+function renderFakeIfTest(addr: EmailData | EmailData[], makeId: () => number) {
+  return Array.isArray(addr)
+    ? addr
+      .map(x => (isTestAddress(x) ? renderFake(x, makeId) : x))
+      .uniq(eq)
+      .toArray
+    : isTestAddress(addr)
+    ? renderFake(addr, makeId)
+    : addr
+}
+
+function renderMailData(md: NonNullable<EmailMsg["to"]>): string {
+  if (Array.isArray(md)) {
+    return md.map(renderMailData).join(", ")
+  }
+  if (typeof md === "string") {
+    return md
+  }
+  return md.email
+}

package/_src/services/Emailer/fake.ts

@@ -0,0 +1,14 @@
+import { pretty } from "@effect-app/prelude/utils"
+import { Emailer } from "./service.js"
+
+const makeFake = Effect.logDebug("FAKE Emailer Service enabled")
+  .map((): Emailer => ({
+    sendMail(msg) {
+      return Effect.logDebug(`Fake send mail`).logAnnotate("msg", pretty(msg))
+    }
+  }))
+
+/**
+ * @tsplus static Emailer.Ops Fake
+ */
+export const FakeSendgrid = makeFake.toLayer(Emailer)

package/_src/services/Emailer/service.ts

@@ -0,0 +1,33 @@
+import type { MailContent, MailData } from "@sendgrid/helpers/classes/mail.js"
+import type { ResponseError } from "@sendgrid/mail"
+import type sgMail from "@sendgrid/mail"
+
+import type { RequestContext } from "../../lib/RequestContext.js"
+
+export interface Emailer {
+  sendMail: (msg: EmailMsgOptionalFrom) => Effect<RequestContext, Error | ResponseError, void>
+}
+
+/**
+ * @tsplus type Emailer.Ops
+ */
+export interface EmailerOps extends Tag<Emailer> {}
+
+export interface SendgridConfig {
+  subjectPrefix: string
+  realMail: boolean
+  defaultFrom: Email | { name?: ReasonableString; email: Email }
+  apiKey: ConfigSecret
+}
+
+export const Emailer: EmailerOps = Tag<Emailer>()
+
+export type EmailMsg = sgMail.MailDataRequired
+export type EmailTemplateMsg = MailData & { templateId: string }
+
+export type EmailMsgOptionalFrom =
+  & Omit<MailData, "from">
+  & (
+    { text: string } | { html: string } | { templateId: string } | { content: NonEmptyReadonlyArray<MailContent> }
+  )
+  & Partial<Pick<EmailMsg, "from">>

package/_src/services/Emailer.ts

@@ -0,0 +1 @@
+export * from "./Emailer/service.js"