effect-app 4.0.0-beta.26 → 4.0.0-beta.260

package/src/{ServiceMap.ts → Context.ts}

@@ -1,21 +1,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * We're doing the long way around here with assignTag, TagBase & TagBaseTagged,
- * because there's a typescript compiler issue where it will complain about Equal.symbol, and Hash.symbol not being accessible.
- * https://github.com/microsoft/TypeScript/issues/52644
- */
+/* eslint-disable import/namespace */
 
-import { type Effect, Layer, type Scope, type Types } from "effect"
-import * as ServiceMap from "effect/ServiceMap"
-import { type Yieldable } from "./Effect.js"
+import * as CTX from "effect/Context"
+import type * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type * as Scope from "effect/Scope"
+import type * as Types from "effect/Types"
 
-export * from "effect/ServiceMap"
+export * from "effect/Context"
 
-export interface Opaque<Self extends object, in out Shape extends object>
-  extends ServiceMap.Key<Self, Self>, Yieldable<Opaque<Self, Shape>, Self, never, Self>
-{
+export interface Opaque<Self extends object, in out Shape extends object> extends CTX.Key<Self, Self> {
   of(this: void, self: Shape): Self
-  serviceMap(self: Shape): ServiceMap.ServiceMap<Self>
+  context(self: Shape): CTX.Context<Self>
   // a version that leverages the Shape -> Self conversion
   toLayer: <E, R>(
     eff: Effect.Effect<Shape, E, R>
@@ -25,11 +21,11 @@ export interface Opaque<Self extends object, in out Shape extends object>
 }
 
 // export interface OpaqueMake<Self extends object, in out Shape extends object, E, R>
-//   extends ServiceMap.Service<Self, Self>
+//   extends CTX.Service<Self, Self>
 // {
 //   // temp while sorting out https://github.com/Effect-TS/effect-smol/pull/1534
 //   of(self: Shape): Self
-//   serviceMap2(self: Shape): ServiceMap.ServiceMap<Self>
+//   contextMap2(self: Shape): CTX.Context<Self>
 //   // a version that leverages the Shape -> Self conversion
 //   toLayer: {
 //     <E, R>(
@@ -44,7 +40,7 @@ export function assignTag<Identifier extends object, Shape extends object = Iden
   creationError?: Error
 ) {
   return <S extends object>(cls: S): S & Opaque<Identifier, Shape> => {
-    const tag = ServiceMap.Service<Identifier, Shape>(key)
+    const tag = CTX.Service<Identifier, Shape>(key)
     let fields = tag
     if (Reflect.ownKeys(cls).includes("key")) {
       const { key, ...rest } = tag
@@ -67,54 +63,51 @@ export function assignTag<Identifier extends object, Shape extends object = Iden
   }
 }
 
-export type ServiceAcessorShape<Self, Type> = Type extends Record<PropertyKey, any> ? {
-    [
-      k in keyof Type as Type[k] extends ((...args: [...infer Args]) => infer Ret)
-        ? ((...args: Readonly<Args>) => Ret) extends Type[k] ? k : never
-        : k
-    ]: Type[k] extends (...args: [...infer Args]) => Effect.Effect<infer A, infer E, infer R>
-      ? (...args: Readonly<Args>) => Effect.Effect<A, E, Self | R>
-      : Type[k] extends (...args: [...infer Args]) => infer A
-        ? (...args: Readonly<Args>) => Effect.Effect<A, never, Self>
-      : Type[k] extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, Self | R>
-      : Effect.Effect<Type[k], never, Self>
-  }
-  : {}
+/** Accessor for a service method that returns a plain value. Wraps via `useSync`. */
+export const accessFn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Shape[K] extends (...args: [...infer Args]) => infer A ? (...args: Readonly<Args>) => Effect.Effect<A, never, Self>
+  : never => ((...args: Array<any>) => Tag.useSync((s: any) => s[key](...args))) as any
 
-/**
- * Only use this in very specific cases where using dependencies directly is prefered, like inside command handlers.
- */
-export const proxify = <T extends object>(Tag: T) =>
-<Self, Shape>():
-  & T
-  & ServiceAcessorShape<Self, Shape> =>
-{
-  const cache = new Map()
-  const done = new Proxy(Tag, {
-    get(_target: any, prop: any, _receiver) {
-      if (prop === "use") {
-        // @ts-expect-error abc
-        return (body) => (Tag as any).use(body)
-      }
-      if (prop in Tag) {
-        return (Tag as any)[prop]
-      }
-      if (cache.has(prop)) {
-        return cache.get(prop)
-      }
-      const fn = (...args: Array<any>) => (Tag as any).use((s: any) => s[prop](...args))
-      const cn = (Tag as any).use((s: any) => s[prop])
-      // @effect-diagnostics effect/floatingEffect:off
-      Object.assign(fn, cn)
-      Object.setPrototypeOf(fn, Object.getPrototypeOf(cn))
-      cache.set(prop, fn)
-      return fn
-    }
-  })
-  return done
-}
+/** Accessor for a service method that returns an Effect. Delegates via `use`. */
+export const accessEffectFn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Shape[K] extends (...args: [...infer Args]) => Effect.Effect<infer A, infer E, infer R>
+  ? (...args: Readonly<Args>) => Effect.Effect<A, E, Self | R>
+  : never => ((...args: Array<any>) => Tag.use((s: any) => s[key](...args))) as any
+
+/** Accessor for a service property (constant). Wraps via `useSync`. */
+export const accessCn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Effect.Effect<Shape[K], never, Self> => Tag.useSync((s) => s[key])
+
+/** Accessor for a service property that is an Effect. Delegates via `use`. */
+export const accessEffectCn = <
+  Self extends object,
+  Shape extends Record<PropertyKey, any>,
+  K extends keyof Shape
+>(
+  Tag: Opaque<Self, Shape>,
+  key: K
+): Shape[K] extends Effect.Effect<infer A, infer E, infer R> ? Effect.Effect<A, E, Self | R>
+  : never => Tag.use((s: any) => s[key]) as any
 
-export const TypeId = "~ServiceMap.Opaque"
+export const TypeId = "~Context.Opaque"
 
 // export function Opaque<const Key extends string>(key: Key) {
 //   return <Identifier extends object, Shape extends object>() => {
@@ -179,7 +172,7 @@ export const Opaque: {
     >
     & { readonly make: Make }
 } = () => (id: string, options: any) => {
-  const svc = ServiceMap.Service()(id, options) as any
+  const svc = CTX.Service()(id, options) as any
   return Object.assign(svc, {
     toLayer: (eff: Effect.Effect<any, any, any>) => {
       return Layer.effect(svc, eff)

package/src/Effect.ts

@@ -2,11 +2,13 @@
 /* eslint-disable prefer-destructuring */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
-import { Effect, Option, Ref, type ServiceMap } from "effect"
 import * as Def from "effect/Deferred"
-import * as Fiber from "effect/Fiber"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
 import type { Scope } from "effect/Scope"
 import type { Semaphore } from "effect/Semaphore"
+import type * as Context from "./Context.js"
 import { curry } from "./Function.js"
 import { typedKeysOf } from "./utils.js"
 
@@ -111,15 +113,11 @@ export function modifyWithPermitWithEffect<A>(ref: Ref.Ref<A>, semaphore: Semaph
     )
 }
 
-export function joinAll<E, A>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<readonly A[], E> {
-  return Fiber.joinAll(fibers) as any
-}
-
 type ServiceA<T> = T extends Effect.Effect<infer S, any, any> ? S
-  : T extends ServiceMap.Service<any, infer S> ? S
+  : T extends Context.Service<any, infer S> ? S
   : never
 type ServiceR<T> = T extends Effect.Effect<any, any, infer R> ? R
-  : T extends ServiceMap.Service<infer I, any> ? I
+  : T extends Context.Service<infer I, any> ? I
   : never
 type ServiceE<T> = T extends Effect.Effect<any, infer E, any> ? E : never
 // type Values<T> = T extends { [s: string]: infer S } ? ServiceA<S> : never
@@ -140,29 +138,29 @@ type ValuesE<T> = T extends { [s: string]: infer S } ? ServiceE<S> : never
  * const b = a({ str: "" })   // valid, but shouldn't be!
  * ```
  */
+// eslint-disable-next-line import/namespace
 export interface EffectUnunified<R, E, A> extends Effect.Effect<R, E, A> {}
 
 export type LowerFirst<S extends PropertyKey> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}`
   : S
-export type LowerServices<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>> = {
+export type LowerServices<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>> = {
   [key in keyof T as LowerFirst<key>]: ServiceA<T[key]>
 }
 
-export function allLower<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>>(
+export function allLower<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>>(
   services: T
 ) {
   return Effect.all(
     typedKeysOf(services).reduce((prev, cur) => {
       const svc = services[cur]!
-      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] =
-        "asEffect" in svc ? svc.asEffect() : svc
+      prev[((cur as string)[0]!.toLowerCase() + (cur as string).slice(1)) as unknown as LowerFirst<typeof cur>] = svc
       return prev
     }, {} as any),
     { concurrency: "inherit" }
   ) as any as Effect.Effect<LowerServices<T>, ValuesE<T>, ValuesR<T>>
 }
 
-export function allLowerWith<T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>, A>(
+export function allLowerWith<T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>, A>(
   services: T,
   fn: (services: LowerServices<T>) => A
 ) {
@@ -170,7 +168,7 @@ export function allLowerWith<T extends Record<string, ServiceMap.Service<any, an
 }
 
 export function allLowerWithEffect<
-  T extends Record<string, ServiceMap.Service<any, any> | Effect.Effect<any, any, any>>,
+  T extends Record<string, Context.Service<any, any> | Effect.Effect<any, any, any>>,
   R,
   E,
   A

package/src/Emailer.ts

@@ -0,0 +1,51 @@
+import * as Data from "effect/Data"
+import type { NonEmptyReadonlyArray } from "./Array.js"
+import * as Context from "./Context.js"
+import type * as Effect from "./Effect.js"
+import type { Email } from "./Schema.js"
+
+export class SendMailError extends Data.TaggedError("SendMailError")<{
+  readonly raw: Error
+}> {}
+
+export class Emailer extends Context.Opaque<Emailer, {
+  sendMail: (msg: EmailMsgOptionalFrom) => Effect.Effect<void, SendMailError>
+}>()("effect-app/Emailer") {}
+
+export type EmailData = Email | {
+  name?: string
+  email: Email
+}
+
+export interface EmailContentPart {
+  type: string
+  value: string
+}
+
+export type EmailRecipients = EmailData | NonEmptyReadonlyArray<EmailData>
+
+export interface EmailMsgBase {
+  readonly to: EmailRecipients
+  readonly cc?: EmailRecipients
+  readonly bcc?: EmailRecipients
+  readonly from: EmailData
+  readonly replyTo?: EmailData
+  readonly subject?: string
+  /**
+   * should multiple `to` addresess be considered multiple emails?
+   * defaults to `true`, not to leak email addresses
+   */
+  readonly isMultiple?: boolean
+}
+
+export type EmailContent =
+  | { text: string }
+  | { html: string }
+  | { templateId: string }
+  | { content: NonEmptyReadonlyArray<EmailContentPart> }
+
+export type EmailMsg =
+  & EmailMsgBase
+  & EmailContent
+
+export type EmailMsgOptionalFrom = Omit<EmailMsgBase, "from"> & Partial<Pick<EmailMsg, "from">> & EmailContent

package/src/Layer.ts

@@ -1,6 +1,10 @@
-import { type Array, Effect, Layer, type Scope, type ServiceMap, type Types } from "effect"
-import { type Yieldable } from "effect/Effect"
+import type * as Array from "effect/Array"
+import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Layer from "effect/Layer"
+import type * as Scope from "effect/Scope"
+import type * as Types from "effect/Types"
+import type * as Context from "./Context.js"
 import { type EffectGenUtils } from "./utils/gen.js"
 
 export * from "effect/Layer"
@@ -11,13 +15,13 @@ type MakeEff<S, E, R> = {
   readonly make: Effect.Effect<S, E, R>
 }
 type MakeGen<S, E = never, R = never> = {
-  readonly make: () => Generator<Yieldable<any, any, E, R>, S, any>
+  readonly make: () => Generator<Effect.Effect<any, E, R>, S>
 }
 type MakeGenNo<S> = {
   readonly make: () => Generator<unknown, S>
 }
 type MakeErr<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Error<Opts["make"]> : never
-type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.ServiceMap<Opts["make"]> : never
+type MakeContext<Opts> = Opts extends { make: () => any } ? EffectGenUtils.Context<Opts["make"]> : never
 
 type DependenciesOpt = { dependencies?: Array.NonEmptyReadonlyArray<Layer.Any> }
 type Dependencies = { dependencies: Array.NonEmptyReadonlyArray<Layer.Any> }
@@ -41,12 +45,12 @@ type PackedOrUnpackedLayer<I, Opts> = Opts extends Dependencies ? PackedLayers<I
 
 export const make: {
   <I, S>(
-    tag: ServiceMap.Service<I, S>
+    tag: Context.Service<I, S>
   ): <Opts extends Make<Types.NoInfer<S>, any, any>>(
     options: Opts
   ) => PackedOrUnpackedLayer<I, Opts>
   <I, S, Opts extends Make<Types.NoInfer<S>, any, any>>(
-    tag: ServiceMap.Service<I, S>,
+    tag: Context.Service<I, S>,
     options: Opts
   ): PackedOrUnpackedLayer<I, Opts>
 } = dual(2, (tag, options) => {

package/src/Model/Repository/Registry.ts

@@ -0,0 +1,34 @@
+import * as Context from "../../Context.js"
+import * as Effect from "../../Effect.js"
+
+export interface RegisteredRepository {
+  readonly seedNamespace: (namespace: string) => Effect.Effect<void>
+}
+
+const make = Effect.sync(() => {
+  const repos = new Map<string, RegisteredRepository>()
+  return {
+    register(modelName: string, repo: RegisteredRepository) {
+      repos.set(modelName, repo)
+    },
+    seedNamespace: (namespace: string) =>
+      Effect.suspend(() =>
+        Effect.forEach(
+          repos.values(),
+          (r) => r.seedNamespace(namespace),
+          { concurrency: "unbounded", discard: true }
+        )
+      ),
+    get entries(): ReadonlyMap<string, RegisteredRepository> {
+      return repos
+    }
+  }
+})
+
+export class RepositoryRegistry extends Context.Opaque<RepositoryRegistry, {
+  readonly register: (modelName: string, repo: RegisteredRepository) => void
+  readonly seedNamespace: (namespace: string) => Effect.Effect<void>
+  readonly entries: ReadonlyMap<string, RegisteredRepository>
+}>()("effect-app/RepositoryRegistry", { make }) {}
+
+export const RepositoryRegistryLive = RepositoryRegistry.toLayer(RepositoryRegistry.make)