@effect-app/infra 4.0.0-beta.2 → 4.0.0-beta.200

package/src/Model/filter/types/path/eager.ts

@@ -217,8 +217,7 @@ export namespace RefinePathValueTests {
     | { nested: { a: string; _tag: "a" } | { b: number; _tag: "b" }; _tag: "ab" }
     | { nested: { b: number; _tag: "b" } | { c: boolean; _tag: "c" }; _tag: "bc" },
     "nested._tag",
-    "a",
-    false
+    "a"
   >
 
   expectTypeOf<test10>().toEqualTypeOf<{

package/src/Model/query/dsl.ts

@@ -54,7 +54,7 @@ type ExtractFieldValuesRefined<T> = T extends QueryTogether<any, infer TFieldVal
 
 export type RelationDirection = "some" | "every"
 export type Relation = { relation: RelationDirection }
-export type Query<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, TFieldValues, false, "initial">
+export type Query<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, TFieldValues>
 export type QueryWhere<
   TFieldValues extends FieldValues,
   TFieldValuesRefined extends TFieldValues = TFieldValues,
@@ -1538,7 +1538,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues, TFieldValuesRefined2, E2>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2>
 
   <
     TFieldValues extends FieldValues,
@@ -1555,7 +1555,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined3, E3>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined3, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined3>
 
   <
     TFieldValues extends FieldValues,
@@ -1577,7 +1577,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined4, E4>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined4, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined4>
 
   <
     TFieldValues extends FieldValues,
@@ -1604,7 +1604,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined5, E5>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined5, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined5>
 
   <
     TFieldValues extends FieldValues,
@@ -1636,7 +1636,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined6, E6>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined6, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined6>
 
   <
     TFieldValues extends FieldValues,
@@ -1673,7 +1673,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined7, E7>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined7, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined7>
 
   <
     TFieldValues extends FieldValues,
@@ -1715,7 +1715,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined8, E8>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined2>
 
   <
     TFieldValues extends FieldValues,
@@ -1762,7 +1762,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined9, E9>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined9, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined9>
 
   <
     TFieldValues extends FieldValues,
@@ -1814,7 +1814,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined10, E10>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined10, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined10>
 
   <
     TFieldValues extends FieldValues,
@@ -1871,7 +1871,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined11, E11>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined11, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined11>
 
   <
     TFieldValues extends FieldValues,
@@ -1933,7 +1933,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined12, E12>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined12, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined12>
 
   <
     TFieldValues extends FieldValues,
@@ -2000,7 +2000,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined13, E13>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined13, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined13>
 
   <
     TFieldValues extends FieldValues,
@@ -2072,7 +2072,7 @@ export type NestedQueriesFreeDisjointRefinement = {
     ) => QueryWhere<TFieldValues, TFieldValuesRefined14, E14>
   ): (
     current: QueryWhere<TFieldValues, TFieldValuesRefined, E>
-  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined14, false>
+  ) => QueryWhere<TFieldValues, TFieldValuesRefined | TFieldValuesRefined14>
 }
 
 export type FilterWhere =
@@ -2099,12 +2099,12 @@ export type WhereEveryOrSome =
       subPath: TFieldName,
       dude: (
         current: Query<TFieldValues[TFieldName][number]>
-      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number], false>,
+      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number]>,
       ...dudes: ((
-        current: QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number], false>
-      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number], false>)[]
+        current: QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number]>
+      ) => QueryWhere<TFieldValues[TFieldName][number], TFieldValues[TFieldName][number]>)[]
     ): (
       current: Query<TFieldValues>
-    ) => QueryWhere<TFieldValues, TFieldValues, false>
+    ) => QueryWhere<TFieldValues, TFieldValues>
   }
   & FilterContinuationsWithSubpath

package/src/Model/query/new-kid-interpreter.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { Array, identity, Match, Option, pipe, S } from "effect-app"
+import { Array, identity, Match, Option, pipe, S, SchemaAST } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { dropUndefinedT } from "effect-app/utils"
 import type { FilterResult } from "../filter/filterApi.js"
@@ -165,7 +165,7 @@ export const toFilter = <
   let select: (keyof TFieldValues | { key: string; subKeys: string[] })[] = []
   // TODO: support more complex (nested) schemas?
   if (schema) {
-    const t = walkTransformation(schema.ast)
+    const t = walkTransformation(SchemaAST.toEncoded(schema.ast))
     if (S.AST.isObjects(t)) {
       select = t.propertySignatures.map((_) => _.name as string)
       for (const prop of t.propertySignatures) {

package/src/Model.ts

@@ -1,3 +1,4 @@
 export * from "./Model/dsl.js"
 export * as Q from "./Model/query.js"
 export { makeRepo } from "./Model/Repository.js"
+export { type RegisteredRepository, RepositoryRegistry, RepositoryRegistryLive } from "./Model/Repository.js"

package/src/QueueMaker/SQLQueue.ts

@@ -1,20 +1,19 @@
 import { getRequestContext, setupRequestContextWithCustomSpan } from "@effect-app/infra/api/setupRequest"
 import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors"
 import { type QueueBase, QueueMeta } from "@effect-app/infra/QueueMaker/service"
-import { SqlClient } from "effect/unstable/sql"
 import { subMinutes } from "date-fns"
-import { Effect, Fiber, Option, S, Tracer } from "effect-app"
-import type { NonEmptyString255 } from "effect-app/Schema"
+import { Effect, Fiber, type NonEmptyReadonlyArray, Option, S, Tracer } from "effect-app"
+import { type NonEmptyString255 } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
-import type { NonEmptyReadonlyArray } from "effect-app"
+import { SqlClient } from "effect/unstable/sql"
 import { SQLModel } from "../adapters/SQL.js"
 import { InfraLogger } from "../logger.js"
 
-export const QueueId = S.Number.pipe(S.brand("QueueId"))
+export const QueueId = S.Finite.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type
 
 // TODO: let the model track and Auto Generate versionColumn on every update instead
-export function makeSQLQueue<
+export const makeSQLQueue = Effect.fnUntraced(function*<
   Evt extends { id: S.StringId; _tag: string },
   DrainEvt extends { id: S.StringId; _tag: string },
   EvtE,
@@ -25,166 +24,136 @@ export function makeSQLQueue<
   schema: S.Codec<Evt, EvtE>,
   drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
-  return Effect.gen(function*() {
-    const base = {
-      id: SQLModel.Generated(QueueId),
-      meta: SQLModel.JsonFromString(QueueMeta),
-      name: S.NonEmptyString255,
-      createdAt: SQLModel.DateTimeInsert,
-      updatedAt: SQLModel.DateTimeUpdate,
-      // TODO: at+owner
-      processingAt: SQLModel.FieldOption(S.Date),
-      finishedAt: SQLModel.FieldOption(S.Date),
-      etag: S.String // TODO: use a SQLModel thing that auto updates it?
-      // TODO: record locking.. / optimistic locking
-      // rowVersion: SQLModel.DateTimeFromNumberWithNow
-    }
-    class Queue extends SQLModel.Class<Queue>("Queue")({
-      body: SQLModel.JsonFromString(schema),
-      ...base
-    }) {}
-    class Drain extends SQLModel.Class<Drain>("Drain")({
-      body: SQLModel.JsonFromString(drainSchema),
-      ...base
-    }) {}
-    const sql = yield* SqlClient.SqlClient
+  const base = {
+    id: SQLModel.Generated(QueueId),
+    meta: SQLModel.JsonFromString(QueueMeta),
+    name: S.NonEmptyString255,
+    createdAt: SQLModel.DateTimeInsert,
+    updatedAt: SQLModel.DateTimeUpdate,
+    // TODO: at+owner
+    processingAt: SQLModel.FieldOption(S.Date),
+    finishedAt: SQLModel.FieldOption(S.Date),
+    etag: S.String // TODO: use a SQLModel thing that auto updates it?
+    // TODO: record locking.. / optimistic locking
+    // rowVersion: SQLModel.DateTimeFromNumberWithNow
+  }
+  class Queue extends SQLModel.Class<Queue>("Queue")({
+    body: SQLModel.JsonFromString(schema),
+    ...base
+  }) {}
+  class Drain extends SQLModel.Class<Drain>("Drain")({
+    body: SQLModel.JsonFromString(drainSchema),
+    ...base
+  }) {}
+  const sql = yield* SqlClient.SqlClient
 
-    const queueRepo = yield* SQLModel.makeRepository(Queue, {
-      tableName: "queue",
-      spanPrefix: "QueueRepo",
-      idColumn: "id",
-      versionColumn: "etag"
-    })
+  const queueRepo = yield* SQLModel.makeRepository(Queue, {
+    tableName: "queue",
+    spanPrefix: "QueueRepo",
+    idColumn: "id",
+    versionColumn: "etag"
+  })
 
-    const drainRepo = yield* SQLModel.makeRepository(Drain, {
-      tableName: "queue",
-      spanPrefix: "DrainRepo",
-      idColumn: "id",
-      versionColumn: "etag"
-    })
+  const drainRepo = yield* SQLModel.makeRepository(Drain, {
+    tableName: "queue",
+    spanPrefix: "DrainRepo",
+    idColumn: "id",
+    versionColumn: "etag"
+  })
 
-    const decodeDrain = S.decodeEffect(Drain)
+  const decodeDrain = S.decodeEffectConcurrently(Drain)
 
-    const drain = Effect
-      .sync(() => subMinutes(new Date(), 15))
-      .pipe(
-        Effect
-          .andThen((limit) =>
-            sql<typeof Drain.Encoded>`SELECT *
+  const drain = Effect.gen(function*() {
+    const limit = subMinutes(new Date(), 15)
+    return yield* sql<typeof Drain.Encoded>`SELECT *
     FROM queue
     WHERE name = ${queueDrainName} AND finishedAt IS NULL AND (processingAt IS NULL OR processingAt < ${limit.getTime()})
     LIMIT 1`
-          )
-      )
+  })
 
-    const q = {
-      offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
-        yield* queueRepo.insertVoid({
-          body,
-          meta,
-          name: queueName,
-          processingAt: Option.none(),
-          finishedAt: Option.none(),
-          etag: crypto.randomUUID()
-        })
-      }),
-      take: Effect.gen(function*() {
-        while (true) {
-          const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
-          if (first) {
-            const dec = yield* decodeDrain(first)
-            const { createdAt, updatedAt, ...rest } = dec
-            return yield* drainRepo.update(
-              { ...rest, processingAt: Option.some(new Date()) } // auto in lib , etag: crypto.randomUUID()
-            )
-          }
-          if (first) return first
-          yield* Effect.sleep(250)
+  const q = {
+    offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
+      yield* queueRepo.insertVoid(Queue.insert.make({
+        body,
+        meta,
+        name: queueName,
+        processingAt: Option.none(),
+        finishedAt: Option.none(),
+        etag: crypto.randomUUID()
+      }))
+    }),
+    take: Effect.gen(function*() {
+      while (true) {
+        const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
+        if (first) {
+          const dec = yield* decodeDrain(first)
+          const { createdAt, updatedAt, ...rest } = dec
+          return yield* drainRepo.update(
+            Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
+          )
         }
-      }),
-      finish: ({ createdAt, updatedAt, ...q }: Drain) =>
-        drainRepo.updateVoid({ ...q, finishedAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
-    }
-    const queue = {
-      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
-        getRequestContext
+        if (first) return first
+        yield* Effect.sleep(250)
+      }
+    }),
+    finish: Effect.fn(function*({ createdAt, updatedAt, ...q }: Drain) {
+      return yield* drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
+    })
+  }
+  const queue = {
+    publish: Effect.fn("queue.publish: " + queueName, { kind: "producer" })(function*(
+      ...messages: NonEmptyReadonlyArray<Evt>
+    ) {
+      yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+      const requestContext = yield* getRequestContext
+      yield* Effect.forEach(messages, (m) => q.offer(m, requestContext), { discard: true })
+    }),
+    drain: <DrainE, DrainR>(
+      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
+      sessionId?: string
+    ) => {
+      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
+      const processMessage = Effect.fnUntraced(function*({ body, meta }: Drain) {
+        let effect = InfraLogger
+          .logDebug(`[${queueDrainName}] Processing incoming message`)
           .pipe(
-            Effect.flatMap((requestContext) =>
-              Effect
-                .forEach(
-                  messages,
-                  (m) => q.offer(m, requestContext),
-                  {
-                    discard: true
+            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+            Effect.andThen(handleEvent(body)),
+            silenceAndReportError,
+            (_) =>
+              setupRequestContextWithCustomSpan(
+                _,
+                meta,
+                `queue.drain: ${queueDrainName}.${body._tag}`,
+                {
+                  captureStackTrace: false,
+                  kind: "consumer",
+                  attributes: {
+                    "queue.name": queueDrainName,
+                    "queue.sessionId": sessionId,
+                    "queue.input": body
                   }
-                )
-            ),
-            Effect.withSpan("queue.publish: " + queueName, {
-              kind: "producer",
-              attributes: { "message_tags": messages.map((_) => _._tag) }
-            }, { captureStackTrace: false })
-          ),
-      drain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-        sessionId?: string
-      ) => {
-        const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-        const processMessage = (msg: Drain) =>
-          Effect
-            .succeed(msg)
-            .pipe(Effect
-              .flatMap(({ body, meta }) => {
-                let effect = InfraLogger
-                  .logDebug(`[${queueDrainName}] Processing incoming message`)
-                  .pipe(
-                    Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-                    Effect.andThen(handleEvent(body)),
-                    silenceAndReportError,
-                    (_) =>
-                      setupRequestContextWithCustomSpan(
-                        _,
-                        meta,
-                        `queue.drain: ${queueDrainName}.${body._tag}`,
-                        {
-                          captureStackTrace: false,
-                          kind: "consumer",
-                          attributes: {
-                            "queue.name": queueDrainName,
-                            "queue.sessionId": sessionId,
-                            "queue.input": body
-                          }
-                        }
-                      )
-                  )
-                if (meta.span) {
-                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
                 }
-                return effect
-              }))
-
-        return q
-          .take
-          .pipe(
-            Effect.flatMap((x) =>
-              processMessage(x).pipe(
-                Effect.uninterruptible,
-                Effect.forkChild,
-                Effect.flatMap(Fiber.join),
-                Effect.tap(q.finish(x))
               )
-            ),
-            silenceAndReportError,
-            Effect.withSpan(`queue.drain: ${queueDrainName}`, {
-              attributes: {
-                "queue.type": "sql",
-                "queue.name": queueDrainName,
-                "queue.sessionId": sessionId
-              }
-            }),
-            Effect.forever
           )
-      }
+        if (meta.span) {
+          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+        }
+        return yield* effect
+      })
+
+      return Effect.fn(`queue.drain: ${queueDrainName}`, {
+        attributes: { "queue.type": "sql", "queue.name": queueDrainName, "queue.sessionId": sessionId }
+      })(function*() {
+        const x = yield* q.take
+        yield* processMessage(x).pipe(
+          Effect.uninterruptible,
+          Effect.forkChild,
+          Effect.flatMap(Fiber.join),
+          Effect.tap(q.finish(x))
+        )
+      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
     }
-    return queue as QueueBase<Evt, DrainEvt>
-  })
-}
+  }
+  return queue as QueueBase<Evt, DrainEvt>
+})