effect-app 4.0.0-beta.99 → 4.0.0

package/src/DataDependencies.ts

@@ -0,0 +1,171 @@
+import type { NonEmptyReadonlyArray } from "effect/Array"
+import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as RequestScopedDependencies from "./RequestScopedDependencies.ts"
+import * as S from "./Schema.ts"
+
+export const DataDependency = S.Union([
+  S.Struct({
+    type: S.Literal("repo"),
+    name: S.String,
+    ids: S.optional(S.NonEmptyArray(S.String))
+  }),
+  S.Struct({
+    type: S.Literal("signal"),
+    name: S.String,
+    ids: S.optional(S.NonEmptyArray(S.String))
+  })
+])
+export type DataDependency = S.Schema.Type<typeof DataDependency>
+
+export const DataDependencies = S.ReadonlySet(DataDependency)
+export type DataDependencies = S.Schema.Type<typeof DataDependencies>
+
+export const empty = (): DataDependencies => new Set()
+
+export const DataDependencySet = S.Struct({
+  reads: DataDependencies,
+  writes: DataDependencies
+})
+export type DataDependencySet = S.Schema.Type<typeof DataDependencySet>
+
+export interface DataDependencyRecorderService {
+  readonly read: (dependency: DataDependency) => Effect.Effect<void>
+  readonly write: (dependency: DataDependency) => Effect.Effect<void>
+  readonly get: Effect.Effect<DataDependencySet>
+  readonly drain: Effect.Effect<DataDependencySet>
+  readonly drainWrites: Effect.Effect<DataDependencies>
+}
+
+const sameDomain = (a: DataDependency, b: DataDependency) => a.type === b.type && a.name === b.name
+
+const dependenciesOverlap = (a: DataDependency, b: DataDependency) => {
+  if (!sameDomain(a, b)) return false
+  if (a.ids === undefined || b.ids === undefined) return true
+  return a.ids.some((id) => b.ids?.includes(id))
+}
+
+const containsDependency = (dependencies: ReadonlySet<DataDependency>, dependency: DataDependency) => {
+  for (const _ of dependencies) {
+    if (dependenciesOverlap(_, dependency)) return true
+  }
+  return false
+}
+
+const appendDependency = (dependency: DataDependency) => (dependencies: DataDependencies): DataDependencies => {
+  const existing = [...dependencies].find((_) => sameDomain(_, dependency))
+  if (existing === undefined) return new Set([...dependencies, dependency])
+  if (existing.ids === undefined) return dependencies
+  if (dependency.ids === undefined) {
+    return new Set([...dependencies].filter((_) => _ !== existing).concat(dependency))
+  }
+  const first = existing.ids[0]
+  const ids: NonEmptyReadonlyArray<string> = [
+    first,
+    ...new Set([...existing.ids.slice(1), ...dependency.ids].filter((id) => id !== first))
+  ]
+  if (ids.length === existing.ids.length) return dependencies
+  const merged = existing.type === "repo" ? repo(existing.name, ids) : signal(existing.name, ids)
+  return new Set([...dependencies].filter((_) => _ !== existing).concat(merged))
+}
+
+export const merge = (...groups: ReadonlyArray<DataDependencies>): DataDependencies => {
+  let merged = empty()
+  for (const group of groups) {
+    for (const dependency of group) merged = appendDependency(dependency)(merged)
+  }
+  return merged
+}
+
+export const DataDependencyRecorder = RequestScopedDependencies.make(
+  "effect-app/DataDependencyRecorder",
+  Effect.gen(function*() {
+    const readsRef = yield* Ref.make(empty())
+    const writesRef = yield* Ref.make(empty())
+    return makeDataDependencyRecorder(readsRef, writesRef)
+  })
+)
+export type DataDependencyRecorder = typeof DataDependencyRecorder
+
+export type DataDependencyRecorderNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError
+
+export const getDataDependencyRecorder = DataDependencyRecorder.current
+
+/**
+ * Guarantee a recorder is in scope for `self`, providing a fresh one per request when none is
+ * (e.g. a top-level client call with no parent query/command tracking its dependencies). An
+ * existing recorder is inherited, so nested calls forward into their parent rather than shadow it.
+ */
+export const ensureDataDependencyRecorder = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.flatMap(
+    DataDependencyRecorder,
+    (current) => current === "root" ? Effect.provide(self, DataDependencyRecorder.layer) : self
+  )
+
+/** Stream variant of {@link ensureDataDependencyRecorder}. */
+export const ensureDataDependencyRecorderStream = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+  Stream.unwrap(
+    Effect.map(
+      DataDependencyRecorder,
+      (current) => current === "root" ? Stream.provide(self, DataDependencyRecorder.layer) : self
+    )
+  )
+
+export const makeDataDependencyRecorder = (
+  readsRef: Ref.Ref<DataDependencies>,
+  writesRef: Ref.Ref<DataDependencies>
+): DataDependencyRecorderService => ({
+  read: (dependency) => Ref.update(readsRef, appendDependency(dependency)),
+  write: (dependency) => Ref.update(writesRef, appendDependency(dependency)),
+  get: Effect.all({
+    reads: Ref.get(readsRef),
+    writes: Ref.get(writesRef)
+  }),
+  drain: Effect.all({
+    reads: Ref.getAndSet(readsRef, empty()),
+    writes: Ref.getAndSet(writesRef, empty())
+  }),
+  drainWrites: Ref.getAndSet(writesRef, empty())
+})
+
+export const repo = (name: string, ids?: NonEmptyReadonlyArray<string>): DataDependency =>
+  ids === undefined ? { type: "repo", name } : { type: "repo", name, ids }
+export const signal = (name: string, ids?: NonEmptyReadonlyArray<string>): DataDependency =>
+  ids === undefined ? { type: "signal", name } : { type: "signal", name, ids }
+
+const RepoReadScope = Context.Reference<DataDependency | undefined>("effect-app/DataDependencies/RepoReadScope", {
+  defaultValue: () => undefined
+})
+
+export const readRepo = (name: string) =>
+  Effect.flatMap(
+    RepoReadScope,
+    (scope) => read(scope?.type === "repo" && scope.name === name ? scope : repo(name))
+  )
+
+export const withRepoReadScope =
+  (name: string, ids: NonEmptyReadonlyArray<string>) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.provideService(self, RepoReadScope, repo(name, ids))
+
+export const QueryReadDependenciesMetaKey = "effect-app.query.readDependencies"
+
+export const read = (dependency: DataDependency) =>
+  getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.read(dependency)))
+
+export const write = (dependency: DataDependency) =>
+  getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.write(dependency)))
+
+export const intersects = (
+  a: ReadonlySet<DataDependency>,
+  b: ReadonlySet<DataDependency>
+) => {
+  for (const dependency of a) {
+    if (containsDependency(b, dependency)) return true
+  }
+  return false
+}
+
+export const isNonEmpty = (dependencies: DataDependencies) => dependencies.size > 0

package/src/Effect.ts

@@ -2,14 +2,15 @@
 /* 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 * 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"
+import type * as Context from "./Context.ts"
+import { curry } from "./Function.ts"
+import { typedKeysOf } from "./utils.ts"
 
 export * from "effect/Effect"
 // v4: Effect interface not re-exported by `export *` due to local binding collision
@@ -112,10 +113,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 +138,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}`
@@ -155,11 +153,10 @@ export function allLower<T extends Record<string, Context.Service<any, any> | Ef
   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" }
+    { concurrency: "unbounded" }
   ) as any as Effect.Effect<LowerServices<T>, ValuesE<T>, ValuesR<T>>
 }
 

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/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), []))]
+}