effect-app 4.0.0-beta.99 → 4.0.1

package/src/Effect.ts

@@ -2,14 +2,13 @@
 /* eslint-disable prefer-destructuring */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
-import { Effect, Option, Ref } from "effect"
-import * as Def from "effect/Deferred"
-import * as Fiber from "effect/Fiber"
-import type { Scope } from "effect/Scope"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
 import type { Semaphore } from "effect/Semaphore"
-import type * as Context from "./Context.js"
-import { curry } from "./Function.js"
-import { typedKeysOf } from "./utils.js"
+import * as Struct from "effect/Struct"
+import type * as Context from "./Context.ts"
+import { curry } from "./Function.ts"
 
 export * from "effect/Effect"
 // v4: Effect interface not re-exported by `export *` due to local binding collision
@@ -93,9 +92,6 @@ export function ifDiff<I, R, E, A>(n: I, orig: I) {
   return (f: (i: I) => Effect.Effect<A, E, R>) => ifDiff_(n, orig, f)
 }
 
-// NOTE: await extension doesnt work via tsplus somehow
-export const await_ = Def.await
-
 /**
  * Ref has atomic modify support if synchronous, for Effect we need a Semaphore.
  */
@@ -112,10 +108,6 @@ 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 Context.Service<any, infer S> ? S
   : never
@@ -141,6 +133,7 @@ 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}`
@@ -153,13 +146,12 @@ export function allLower<T extends Record<string, Context.Service<any, any> | Ef
   services: T
 ) {
   return Effect.all(
-    typedKeysOf(services).reduce((prev, cur) => {
+    Struct.keys(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[0]!.toLowerCase() + cur.slice(1)) as unknown as LowerFirst<typeof cur>] = svc
       return prev
     }, {} as any),
-    { concurrency: "inherit" }
+    { concurrency: "unbounded" }
   ) as any as Effect.Effect<LowerServices<T>, ValuesE<T>, ValuesR<T>>
 }
 
@@ -189,17 +181,3 @@ export function catchAllMap<E, A2>(f: (e: E) => A2) {
   return <R, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A2 | A, never, R> =>
     Effect.catch(self, (err: E) => Effect.sync(() => f(err)))
 }
-
-/**
- * Annotates each log in this scope with the specified log annotation.
- */
-export function annotateLogscoped(key: string, value: string): Effect.Effect<void, never, Scope> {
-  return Effect.annotateLogsScoped(key, value)
-}
-
-/**
- * Annotates each log in this scope with the specified log annotations.
- */
-export function annotateLogsScoped(kvps: Record<string, string>): Effect.Effect<void, never, Scope> {
-  return Effect.annotateLogsScoped(kvps)
-}

package/src/Emailer.ts

@@ -0,0 +1,51 @@
+import * as Data from "effect/Data"
+import type { NonEmptyReadonlyArray } from "./Array.ts"
+import * as Context from "./Context.ts"
+import type * as Effect from "./Effect.ts"
+import type { Email } from "./Schema.ts"
+
+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/Function.ts

@@ -1,13 +1,6 @@
 export * from "effect/Function"
 export type { Predicate, Refinement } from "effect/Predicate"
 
-/**
- * Construct tuples
- */
-export function tuple<T extends ReadonlyArray<any>>(...t: T): Readonly<T> {
-  return t
-}
-
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 export function tupledCurry<A, B, C>(f: (b: B) => (a: A) => C) {

package/src/Inputify.type.ts

@@ -1,6 +1,6 @@
 import type { BuiltInObject } from "effect-app/utils"
 
-import type { Primitive } from "./Widen.type.js"
+import type { Primitive } from "./Widen.type.ts"
 
 // Get rid of Date | string, and replace with Date | null
 export type Inputify<T> = Date extends T ? string extends T ? Date | null

package/src/Layer.ts

@@ -1,8 +1,11 @@
-import { type Array, Effect, Layer, type Scope, 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 type * as Context from "./Context.js"
-import { type EffectGenUtils } from "./utils/gen.js"
+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.ts"
+import { type EffectGenUtils } from "./utils/gen.ts"
 
 export * from "effect/Layer"
 
@@ -12,7 +15,7 @@ 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>

package/src/Model/Repository/Registry.ts

@@ -0,0 +1,35 @@
+import type { DatabaseError } from "../../client/errors.ts"
+import * as Context from "../../Context.ts"
+import * as Effect from "../../Effect.ts"
+
+export interface RegisteredRepository {
+  readonly seedNamespace: (namespace: string) => Effect.Effect<void, DatabaseError>
+}
+
+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, DatabaseError>
+  readonly entries: ReadonlyMap<string, RegisteredRepository>
+}>()("effect-app/RepositoryRegistry", { make }) {}
+
+export const RepositoryRegistryLive = RepositoryRegistry.toLayer(RepositoryRegistry.make)

package/src/Model/Repository/dependency.ts

@@ -0,0 +1,32 @@
+import * as S from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
+
+const RepositoryDependencyAnnotation = "effect-app/Repository/dependency"
+
+/** Marks an encoded model field as an identity alias for repository invalidation. */
+export const repositoryDependency = <Schema extends S.Top>(schema: Schema): Schema["Rebuild"] =>
+  S.annotateEncoded({ [RepositoryDependencyAnnotation]: true })(schema)
+
+/** @internal */
+export const repositoryDependencyPaths = (schema: S.Schema<unknown>): readonly string[] => {
+  const visit = (ast: SchemaAST.AST, path: readonly string[]): readonly string[] => {
+    const annotations = ast.checks?.at(-1)?.annotations ?? ast.annotations
+    if (annotations?.[RepositoryDependencyAnnotation] === true) return [path.join(".")]
+    if (SchemaAST.isDeclaration(ast)) return ast.typeParameters.flatMap((parameter) => visit(parameter, path))
+    if (SchemaAST.isUnion(ast)) return ast.types.flatMap((member) => visit(member, path))
+    if (SchemaAST.isObjects(ast)) {
+      return ast.propertySignatures.flatMap((property) =>
+        typeof property.name === "string" ? visit(property.type, [...path, property.name]) : []
+      )
+    }
+    if (SchemaAST.isArrays(ast)) {
+      return [
+        ...ast.elements.flatMap((element, index) => visit(element, [...path, String(index)])),
+        ...ast.rest.flatMap((element) => visit(element, [...path, "-1"]))
+      ]
+    }
+    return []
+  }
+
+  return [...new Set(visit(SchemaAST.toEncoded(schema.ast), []))]
+}

package/src/Model/Repository/ext.ts

@@ -0,0 +1,374 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import * as Exit from "effect/Exit"
+import * as Request from "effect/Request"
+import * as RequestResolver from "effect/RequestResolver"
+import * as Array from "../../Array.ts"
+import type { NonEmptyArray } from "../../Array.ts"
+import { type DatabaseError, type InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "../../client/errors.ts"
+import * as Effect from "../../Effect.ts"
+import * as Option from "../../Option.ts"
+import { type FixEnv, type PureEnv, runTerm } from "../../Pure.ts"
+import { AnyPureDSL } from "../dsl.ts"
+import type { FieldValues } from "../filter/types.ts"
+import type { Query, QueryEnd, QueryWhere } from "../query.ts"
+import * as Q from "../query.ts"
+import type { Repository } from "./service.ts"
+
+interface BatchOptions {
+  readonly batch?: true | number
+}
+
+const asReadonlyArray = <T>(itemOrItems: T | ReadonlyArray<T>): ReadonlyArray<T> =>
+  globalThis.Array.isArray(itemOrItems)
+    ? itemOrItems as ReadonlyArray<T>
+    : [itemOrItems as T]
+
+const getBatchSize = (batch?: true | number) =>
+  batch === true
+    ? 100
+    : typeof batch === "number" && Number.isFinite(batch) && batch > 0
+    ? Math.floor(batch)
+    : undefined
+
+export const extendRepo = <
+  T,
+  Encoded extends FieldValues,
+  Evt,
+  ItemType extends string,
+  IdKey extends keyof T & keyof Encoded,
+  RSchema,
+  RPublish,
+  RProvided = never
+>(
+  repo: Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish, RProvided>
+) => {
+  const get = (id: T[IdKey]) =>
+    repo.find(id).pipe(
+      Effect.flatMap(Option.match({
+        onNone: () => Effect.fail(new NotFoundError<ItemType>({ type: repo.itemType, id })),
+        onSome: Effect.succeed
+      }))
+    )
+  function saveManyWithPure_<
+    R,
+    A,
+    E,
+    S1 extends T,
+    S2 extends T
+  >(
+    items: Iterable<S1>,
+    pure: Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+  ) {
+    return saveAllWithEffectInt(
+      runTerm(pure, [...items])
+    )
+  }
+
+  function saveWithPure_<
+    R,
+    A,
+    E,
+    S1 extends T,
+    S2 extends T
+  >(
+    item: S1,
+    pure: Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>>
+  ) {
+    return saveAllWithEffectInt(
+      runTerm(pure, item)
+        .pipe(Effect
+          .map(([item, events, a]) => [[item], events, a]))
+    )
+  }
+
+  function saveAllWithEffectInt<
+    P extends T,
+    R,
+    E,
+    A
+  >(
+    gen: Effect.Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>
+  ): Effect.Effect<
+    A,
+    E | InvalidStateError | OptimisticConcurrencyException | DatabaseError,
+    R | RSchema | RPublish
+  > {
+    return Effect.flatMap(gen, ([items, events, a]) => repo.saveAndPublish(items, events).pipe(Effect.map(() => a)))
+  }
+
+  function saveManyWithPureBatched_<
+    R,
+    A,
+    E,
+    S1 extends T,
+    S2 extends T
+  >(
+    items: Iterable<S1>,
+    pure: Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>,
+    batchSize = 100
+  ) {
+    return Effect.forEach(
+      Array.chunksOf(items, batchSize),
+      (batch) =>
+        saveAllWithEffectInt(
+          runTerm(pure, batch)
+        )
+    )
+  }
+
+  type PureStoreError = InvalidStateError | OptimisticConcurrencyException | DatabaseError
+
+  const queryAndSavePure: {
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Query<Encoded>
+      ) => QueryEnd<Encoded, "one">,
+      pure: Effect.Effect<A, E2, FixEnv<R2, Evt, T, T2>>
+    ): Effect.Effect<
+      A,
+      PureStoreError | NotFoundError<ItemType> | E2,
+      | RSchema
+      | RPublish
+      | Exclude<R2, {
+        env: PureEnv<Evt, T, T2>
+      }>
+    >
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Query<Encoded>
+      ) =>
+        | Query<Encoded>
+        | QueryWhere<Encoded>
+        | QueryEnd<Encoded>,
+      pure: Effect.Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>
+    ): Effect.Effect<
+      A,
+      PureStoreError | E2,
+      | RSchema
+      | RPublish
+      | Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+    <A, E2, R2, T2 extends T>(
+      q: (
+        q: Query<Encoded>
+      ) =>
+        | Query<Encoded>
+        | QueryWhere<Encoded>
+        | QueryEnd<Encoded>,
+      pure: Effect.Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>,
+      batch: "batched" | number
+    ): Effect.Effect<
+      A[],
+      PureStoreError | E2,
+      | RSchema
+      | RPublish
+      | Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+  } = ((q: any, pure: any, batch?: "batched" | number) =>
+    // Overload dispatch: query returns T | T[]; pure helpers are generic on item shape.
+    // Runtime path is query → pure term → saveAndPublish (which raises DatabaseError).
+    repo.query(q).pipe(
+      Effect.andThen((_) =>
+        Array.isArray(_)
+          ? batch === undefined
+            ? saveManyWithPure_(_ as T[], pure)
+            : saveManyWithPureBatched_(_ as T[], pure, batch === "batched" ? 100 : batch)
+          : saveWithPure_(_ as T, pure)
+      )
+    )) as typeof queryAndSavePure
+
+  const saveManyWithPure: {
+    <R, A, E, S1 extends T, S2 extends T>(
+      items: Iterable<S1>,
+      pure: Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+    ): Effect.Effect<
+      A,
+      PureStoreError | E,
+      | RSchema
+      | RPublish
+      | Exclude<R, {
+        env: PureEnv<Evt, readonly S1[], readonly S2[]>
+      }>
+    >
+    <R, A, E, S1 extends T, S2 extends T>(
+      items: Iterable<S1>,
+      pure: Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>,
+      batch: "batched" | number
+    ): Effect.Effect<
+      A[],
+      PureStoreError | E,
+      | RSchema
+      | RPublish
+      | Exclude<R, {
+        env: PureEnv<Evt, readonly S1[], readonly S2[]>
+      }>
+    >
+  } = ((items: Iterable<T>, pure: any, batch?: "batched" | number) =>
+    batch
+      ? Effect.forEach(
+        Array.chunksOf([...items], batch === "batched" ? 100 : batch),
+        (batchItems) =>
+          saveAllWithEffectInt(
+            runTerm(pure, batchItems as any)
+          )
+      )
+      : saveAllWithEffectInt(
+        runTerm(pure, [...items] as any)
+      )) as typeof saveManyWithPure
+
+  const byIdAndSaveWithPure: {
+    <R, A, E, S2 extends T>(
+      id: T[IdKey],
+      pure: Effect.Effect<A, E, FixEnv<R, Evt, T, S2>>
+    ): Effect.Effect<
+      A,
+      PureStoreError | NotFoundError<ItemType> | E,
+      | RSchema
+      | RPublish
+      | Exclude<R, {
+        env: PureEnv<Evt, T, S2>
+      }>
+    >
+  } = (id, pure) => get(id).pipe(Effect.flatMap((item) => saveWithPure_(item, pure)))
+
+  // query can raise DatabaseError; NotFound is completed per-entry. Dual package
+  // round-trips may still surface other store errors via failCause — keep channel honest.
+  type Req =
+    & Request.Request<T, NotFoundError<ItemType> | DatabaseError>
+    & { _tag: `Get${ItemType}`; id: T[IdKey] }
+  const _request = Request.tagged<Req>(`Get${repo.itemType}`)
+
+  const requestResolver = RequestResolver
+    .make((
+      entries: NonEmptyArray<Request.Entry<Req>>,
+      _key: unknown
+    ) =>
+      (repo.query(Q.where(repo.idKey as any, "in" as any, entries.map((_) => _.request.id)) as any) as Effect.Effect<
+        readonly T[],
+        DatabaseError
+      >)
+        .pipe(
+          Effect.andThen((items) =>
+            Effect.forEach(entries, (entry) =>
+              Request.complete(
+                Array
+                  .findFirst(items, (_) => _[repo.idKey] === entry.request.id)
+                  .pipe(Option.match({
+                    onNone: () => Exit.fail(new NotFoundError({ type: repo.itemType, id: entry.request.id })),
+                    onSome: Exit.succeed
+                  }))
+              )(entry), { discard: true })
+          ),
+          Effect
+            .catchCause((cause) =>
+              Effect.forEach(entries, (entry) => Request.complete(Exit.failCause(cause))(entry), { discard: true })
+            )
+        )
+    )
+    .pipe(
+      RequestResolver.batchN(20)
+    )
+
+  const exts = {
+    request: (id: T[IdKey]) => Effect.request(_request({ id }), requestResolver),
+    get,
+    log: (evt: Evt) => AnyPureDSL.log(evt),
+    /**
+     * Enables chunked writes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are saved independently.
+     */
+    save: (itemOrItems: T | ReadonlyArray<T>, options?: BatchOptions) => {
+      const items = asReadonlyArray(itemOrItems)
+      if (!Array.isReadonlyArrayNonEmpty(items)) {
+        return Effect.void
+      }
+      const batchSize = getBatchSize(options?.batch)
+      if (batchSize === undefined) {
+        return repo.saveAndPublish(items)
+      }
+      return Effect.forEach(
+        Array.chunksOf(items, batchSize),
+        (batch) => repo.saveAndPublish(batch),
+        { discard: true }
+      )
+    },
+    saveWithEvents: (events: Iterable<Evt>) => (...items: NonEmptyArray<T>) => repo.saveAndPublish(items, events),
+    /**
+     * Enables chunked deletes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are removed independently.
+     */
+    remove: (itemOrItems: T | ReadonlyArray<T>, options?: BatchOptions) => {
+      const items = asReadonlyArray(itemOrItems)
+      if (!Array.isReadonlyArrayNonEmpty(items)) {
+        return Effect.void as Effect.Effect<void, DatabaseError, RSchema | RPublish>
+      }
+      const batchSize = getBatchSize(options?.batch)
+      if (batchSize === undefined) {
+        return repo.removeAndPublish(items)
+      }
+      return Effect.forEach(
+        Array.chunksOf(items, batchSize),
+        (batch) => repo.removeAndPublish(batch),
+        { discard: true }
+      )
+    },
+    /**
+     * Enables chunked deletes for large batches via `options.batch`.
+     * Note: batching breaks transactional properties because chunks are removed independently.
+     */
+    removeById: (idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>, options?: BatchOptions) => {
+      const ids = asReadonlyArray(idOrIds)
+      if (!Array.isReadonlyArrayNonEmpty(ids)) {
+        return Effect.void as Effect.Effect<void, DatabaseError, RSchema>
+      }
+      const batchSize = getBatchSize(options?.batch)
+      if (batchSize === undefined) {
+        return repo.removeById(ids)
+      }
+      return Effect.forEach(
+        Array.chunksOf(ids, batchSize),
+        (batch) => repo.removeById(batch),
+        { discard: true }
+      )
+    },
+    queryAndSavePure,
+    saveManyWithPure,
+    byIdAndSaveWithPure,
+    saveWithPure: <
+      R,
+      A,
+      E,
+      S1 extends T,
+      S2 extends T
+    >(
+      item: S1,
+      pure: Effect.Effect<A, E, FixEnv<R, Evt, S1, S2>>
+    ) =>
+      saveAllWithEffectInt(
+        runTerm(pure, item)
+          .pipe(Effect.map(([item, events, a]) => [[item], events, a]))
+      )
+  }
+
+  return {
+    ...repo,
+    ...exts
+  } as Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish, RProvided> & typeof exts
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ExtendedRepository<
+  T,
+  Encoded extends FieldValues,
+  Evt,
+  ItemType extends string,
+  IdKey extends keyof T & keyof Encoded,
+  RSchema,
+  RPublish,
+  RProvided = never
+> extends ReturnType<typeof extendRepo<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish, RProvided>> {}