effect-app 4.0.0-beta.307 → 4.0.0-beta.309

package/src/Model/Repository/ext.ts

@@ -5,7 +5,7 @@ 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 InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "../../client/errors.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"
@@ -89,7 +89,11 @@ export const extendRepo = <
     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)))
   }
 
@@ -113,6 +117,8 @@ export const extendRepo = <
     )
   }
 
+  type PureStoreError = InvalidStateError | OptimisticConcurrencyException | DatabaseError
+
   const queryAndSavePure: {
     <A, E2, R2, T2 extends T>(
       q: (
@@ -121,8 +127,10 @@ export const extendRepo = <
       pure: Effect.Effect<A, E2, FixEnv<R2, Evt, T, T2>>
     ): Effect.Effect<
       A,
-      InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E2,
-      Exclude<R2, {
+      PureStoreError | NotFoundError<ItemType> | E2,
+      | RSchema
+      | RPublish
+      | Exclude<R2, {
         env: PureEnv<Evt, T, T2>
       }>
     >
@@ -136,7 +144,7 @@ export const extendRepo = <
       pure: Effect.Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>
     ): Effect.Effect<
       A,
-      InvalidStateError | OptimisticConcurrencyException | E2,
+      PureStoreError | E2,
       | RSchema
       | RPublish
       | Exclude<R2, {
@@ -154,23 +162,25 @@ export const extendRepo = <
       batch: "batched" | number
     ): Effect.Effect<
       A[],
-      InvalidStateError | OptimisticConcurrencyException | E2,
+      PureStoreError | E2,
       | RSchema
       | RPublish
       | Exclude<R2, {
         env: PureEnv<Evt, readonly T[], readonly T2[]>
       }>
     >
-  } = (q, pure, batch?: "batched" | number) =>
+  } = ((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 any, pure as any)
-            : saveManyWithPureBatched_(_ as any, pure as any, batch === "batched" ? 100 : batch)
-          : saveWithPure_(_ as any, pure as any)
+            ? saveManyWithPure_(_ as T[], pure)
+            : saveManyWithPureBatched_(_ as T[], pure, batch === "batched" ? 100 : batch)
+          : saveWithPure_(_ as T, pure)
       )
-    ) as any
+    )) as typeof queryAndSavePure
 
   const saveManyWithPure: {
     <R, A, E, S1 extends T, S2 extends T>(
@@ -178,7 +188,7 @@ export const extendRepo = <
       pure: Effect.Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
     ): Effect.Effect<
       A,
-      InvalidStateError | OptimisticConcurrencyException | E,
+      PureStoreError | E,
       | RSchema
       | RPublish
       | Exclude<R, {
@@ -191,25 +201,25 @@ export const extendRepo = <
       batch: "batched" | number
     ): Effect.Effect<
       A[],
-      InvalidStateError | OptimisticConcurrencyException | E,
+      PureStoreError | E,
       | RSchema
       | RPublish
       | Exclude<R, {
         env: PureEnv<Evt, readonly S1[], readonly S2[]>
       }>
     >
-  } = (items, pure, batch?: "batched" | number) =>
+  } = ((items: Iterable<T>, pure: any, batch?: "batched" | number) =>
     batch
       ? Effect.forEach(
-        Array.chunksOf(items, batch === "batched" ? 100 : batch),
-        (batch) =>
+        Array.chunksOf([...items], batch === "batched" ? 100 : batch),
+        (batchItems) =>
           saveAllWithEffectInt(
-            runTerm(pure, batch)
+            runTerm(pure, batchItems as any)
           )
       )
       : saveAllWithEffectInt(
-        runTerm(pure, [...items])
-      )
+        runTerm(pure, [...items] as any)
+      )) as typeof saveManyWithPure
 
   const byIdAndSaveWithPure: {
     <R, A, E, S2 extends T>(
@@ -217,17 +227,19 @@ export const extendRepo = <
       pure: Effect.Effect<A, E, FixEnv<R, Evt, T, S2>>
     ): Effect.Effect<
       A,
-      InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E,
+      PureStoreError | NotFoundError<ItemType> | E,
       | RSchema
       | RPublish
       | Exclude<R, {
         env: PureEnv<Evt, T, S2>
       }>
     >
-  } = (id, pure): any => get(id).pipe(Effect.flatMap((item) => saveWithPure_(item, pure)))
+  } = (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>>
+    & Request.Request<T, NotFoundError<ItemType> | DatabaseError>
     & { _tag: `Get${ItemType}`; id: T[IdKey] }
   const _request = Request.tagged<Req>(`Get${repo.itemType}`)
 
@@ -237,9 +249,9 @@ export const extendRepo = <
       _key: unknown
     ) =>
       (repo.query(Q.where(repo.idKey as any, "in" as any, entries.map((_) => _.request.id)) as any) as Effect.Effect<
-        readonly T[]
+        readonly T[],
+        DatabaseError
       >)
-        // TODO
         .pipe(
           Effect.andThen((items) =>
             Effect.forEach(entries, (entry) =>
@@ -270,7 +282,7 @@ export const extendRepo = <
      * 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) => {
+    save: (itemOrItems: T | ReadonlyArray<T>, options?: BatchOptions) => {
       const items = asReadonlyArray(itemOrItems)
       if (!Array.isReadonlyArrayNonEmpty(items)) {
         return Effect.void
@@ -284,23 +296,16 @@ export const extendRepo = <
         (batch) => repo.saveAndPublish(batch),
         { discard: true }
       )
-    }) as (
-      itemOrItems: T | ReadonlyArray<T>,
-      options?: BatchOptions
-    ) => Effect.Effect<
-      void,
-      InvalidStateError | OptimisticConcurrencyException,
-      RSchema | RPublish
-    >,
+    },
     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) => {
+    remove: (itemOrItems: T | ReadonlyArray<T>, options?: BatchOptions) => {
       const items = asReadonlyArray(itemOrItems)
       if (!Array.isReadonlyArrayNonEmpty(items)) {
-        return Effect.void
+        return Effect.void as Effect.Effect<void, DatabaseError, RSchema | RPublish>
       }
       const batchSize = getBatchSize(options?.batch)
       if (batchSize === undefined) {
@@ -311,18 +316,15 @@ export const extendRepo = <
         (batch) => repo.removeAndPublish(batch),
         { discard: true }
       )
-    }) as (
-      itemOrItems: T | ReadonlyArray<T>,
-      options?: BatchOptions
-    ) => Effect.Effect<void, never, RSchema | RPublish>,
+    },
     /**
      * 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) => {
+    removeById: (idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>, options?: BatchOptions) => {
       const ids = asReadonlyArray(idOrIds)
       if (!Array.isReadonlyArrayNonEmpty(ids)) {
-        return Effect.void
+        return Effect.void as Effect.Effect<void, DatabaseError, RSchema>
       }
       const batchSize = getBatchSize(options?.batch)
       if (batchSize === undefined) {
@@ -333,10 +335,7 @@ export const extendRepo = <
         (batch) => repo.removeById(batch),
         { discard: true }
       )
-    }) as (
-      idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>,
-      options?: BatchOptions
-    ) => Effect.Effect<void, never, RSchema>,
+    },
     queryAndSavePure,
     saveManyWithPure,
     byIdAndSaveWithPure,

package/src/Model/Repository/internal/internal.ts

@@ -25,8 +25,10 @@ import { type Codec, NonNegativeInt } from "../../../Schema.ts"
 import * as SchemaAST from "../../../SchemaAST.ts"
 import { setupRequestContextFromCurrent } from "../../../setupRequest.ts"
 import { type FilterArgs, getContextMap, type PersistenceModelType, type StoreConfig, storeId, StoreMaker } from "../../../Store.ts"
+import type { FilterResult } from "../../filter/filterApi.ts"
 import type { FieldValues } from "../../filter/types.ts"
 import * as Q from "../../query.ts"
+import { repositoryDependencyPaths } from "../dependency.ts"
 import type { ChangeFeed, ChangeFeedEvent, Repository } from "../service.ts"
 import { ValidationError, ValidationResult } from "../validation.ts"
 
@@ -147,16 +149,55 @@ export function makeRepoInternal<
           )
 
           const store = yield* mkStore(args.makeInitial, args.config)
+          const dependencyPaths = repositoryDependencyPaths(schema)
           const recordRead = DataDependencies.readRepo(name)
           const entityDependency = (ids: NonEmptyReadonlyArray<T[IdKey]>) =>
             DataDependencies.repo(name, [String(ids[0]), ...ids.slice(1).map(String)])
+          const valuesAtPath = (value: unknown, path: string): readonly unknown[] => {
+            if (path.length === 0) return [value]
+            const [head, ...tail] = path.split(".")
+            if (head === undefined) return [value]
+            if (head === "-1") {
+              return globalThis.Array.isArray(value)
+                ? value.flatMap((item) => valuesAtPath(item, tail.join(".")))
+                : []
+            }
+            return typeof value === "object" && value !== null
+              ? valuesAtPath((value as Record<string, unknown>)[head], tail.join("."))
+              : []
+          }
+          const dependencyIds = (item: T): NonEmptyReadonlyArray<string> => {
+            const configured = dependencyPaths
+              .flatMap((path) => valuesAtPath(item, String(path)))
+              .filter((value): value is string => typeof value === "string") ?? []
+            const ids = args.dependencyIds?.(item) ?? [String(item[idKey]), ...configured]
+            return [ids[0], ...ids.slice(1)]
+          }
           const itemDependencies = (item: T) => {
-            const ids = args.dependencyIds?.(item) ?? [String(item[idKey])]
+            const ids = dependencyIds(item)
             return [
               DataDependencies.repo(name, ids),
               ...(args.additionalWriteDependencies?.(item) ?? [])
             ]
           }
+          const queryDependencyIds = (filter: readonly FilterResult[] | undefined): readonly string[] => {
+            if (!filter) return []
+            const paths = new Set([String(idKey), ...dependencyPaths])
+            const visit = (items: readonly FilterResult[]): readonly string[] => {
+              if (items.some((item) => item.t === "or" || item.t === "or-scope")) return []
+              return items.flatMap((item) => {
+                if ("result" in item) return visit(item.result)
+                if (!paths.has(item.path)) return []
+                const value: unknown = item.value
+                if (item.op === "eq" && typeof value === "string") return [value]
+                if (item.op === "in" && globalThis.Array.isArray(value)) {
+                  return value.filter((entry): entry is string => typeof entry === "string")
+                }
+                return []
+              })
+            }
+            return [...new Set(visit(filter))]
+          }
           const recordEntityRead = (id: T[IdKey]) => DataDependencies.read(entityDependency([id]))
           const recordEntityWrite = (ids: NonEmptyReadonlyArray<T[IdKey]>) =>
             DataDependencies.write(entityDependency(ids))
@@ -166,12 +207,6 @@ export function makeRepoInternal<
               DataDependencies.write,
               { discard: true }
             )
-          const recordAdditionalItemWrites = (items: ReadonlyArray<T>) =>
-            Effect.forEach(
-              DataDependencies.merge(new Set(items.flatMap((item) => args.additionalWriteDependencies?.(item) ?? []))),
-              DataDependencies.write,
-              { discard: true }
-            )
           const cms = Effect.map(getContextMap.pipe(Effect.orDie), (_) => ({
             get: (id: string) => _.get(`${name}.${id}`),
             set: (id: string, etag: string | undefined) => _.set(`${name}.${id}`, etag)
@@ -353,7 +388,7 @@ export function makeRepoInternal<
               const it = Chunk.fromIterable(items)
               if (Chunk.isNonEmpty(it)) {
                 const values = Chunk.toReadonlyArray(it)
-                const previous = args.additionalWriteDependencies
+                const previous = args.additionalWriteDependencies || args.dependencyIds || dependencyPaths.length > 0
                   ? yield* loadExistingItems(values.map((item) => item[idKey]))
                   : []
                 yield* recordItemWrite([values[0], ...values.slice(1), ...previous])
@@ -414,8 +449,9 @@ export function makeRepoInternal<
                 return
               }
               yield* recordEntityWrite(ids)
-              if (args.additionalWriteDependencies) {
-                yield* loadExistingItems(ids).pipe(Effect.flatMap(recordAdditionalItemWrites))
+              if (args.additionalWriteDependencies || args.dependencyIds || dependencyPaths.length > 0) {
+                const previous = yield* loadExistingItems(ids)
+                if (Array.isReadonlyArrayNonEmpty(previous)) yield* recordItemWrite(previous)
               }
               const { set } = yield* cms
               const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
@@ -485,6 +521,10 @@ export function makeRepoInternal<
             ): Effect.Effect<readonly A[], never, Exclude<R, RCtx>>
           } = (<A, R, EncodedRefined extends Encoded = Encoded>(q: Q.QAll<Encoded, EncodedRefined, A, R>) => {
             const a = Q.toFilter(q, schema)
+            const scopedIds = queryDependencyIds(a.filter)
+            const recordQueryRead = Array.isReadonlyArrayNonEmpty(scopedIds)
+              ? DataDependencies.read(DataDependencies.repo(name, scopedIds))
+              : recordRead
             // Mode dispatch — see `Q.project` JSDoc for the contract:
             //   aggregate: GROUP BY + aggregate functions at DB level; decode raw rows with schema; SchemaError surfaces.
             //   project  : decode raw encoded rows with schema; no PM reverse-mapping; SchemaError surfaces.
@@ -563,7 +603,7 @@ export function makeRepoInternal<
                   "db.response.returned_rows": Array.isArray(r) ? r.length : 1
                 })
               ),
-              Effect.tap(() => recordRead),
+              Effect.tap(() => recordQueryRead),
               Effect.withSpan("Repository.query", {
                 kind: "client",
                 attributes: { "app.entity": name }

package/src/Model/Repository.ts

@@ -1,3 +1,4 @@
+export { repositoryDependency } from "./Repository/dependency.ts"
 export * from "./Repository/ext.ts"
 export * from "./Repository/legacy.ts"
 export { makeRepo } from "./Repository/makeRepo.ts"

package/src/Model/query/dsl.ts

@@ -707,7 +707,7 @@ export const relation = <
   expr: {
     field: (field: FieldPath<RelationElement<TFieldValues, P>>): ComputedProjectionMathExpression => ({
       _tag: "field",
-      field: field as string
+      field
     }),
     mul: (
       left: ComputedProjectionMathExpression,
@@ -716,33 +716,33 @@ export const relation = <
   },
   length: (): ComputedProjectionExpression<number> => ({
     _tag: "relation-length",
-    path: path as string
+    path
   }),
   count: (operation?: ComputedProjectionOperation): ComputedProjectionExpression<number> =>
     operation
       ? {
         _tag: "relation-count",
-        path: path as string,
+        path,
         operation
       }
       : {
         _tag: "relation-count",
-        path: path as string
+        path
       },
   any: (operation?: ComputedProjectionOperation): ComputedProjectionExpression<boolean> =>
     operation
       ? {
         _tag: "relation-any",
-        path: path as string,
+        path,
         operation
       }
       : {
         _tag: "relation-any",
-        path: path as string
+        path
       },
   every: (operation: ComputedProjectionOperation): ComputedProjectionExpression<boolean> => ({
     _tag: "relation-every",
-    path: path as string,
+    path,
     operation
   }),
   distinctCount: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
@@ -752,14 +752,14 @@ export const relation = <
     operation
       ? {
         _tag: "relation-distinct-count",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         operation
       }
       : {
         _tag: "relation-distinct-count",
-        path: path as string,
-        field: field as string
+        path,
+        field
       },
   sum: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
     field: F,
@@ -768,14 +768,14 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         operation
       }
       : {
         _tag: "relation-sum",
-        path: path as string,
-        field: field as string
+        path,
+        field
       },
   sumExpr: (
     expression: ComputedProjectionMathExpression,
@@ -784,13 +784,13 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum-expr",
-        path: path as string,
+        path,
         expression,
         operation
       }
       : {
         _tag: "relation-sum-expr",
-        path: path as string,
+        path,
         expression
       },
   sumExprBy: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
@@ -803,16 +803,16 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum-expr-by",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string,
+        unit: options.unit,
         operation
       }
       : {
         _tag: "relation-sum-expr-by",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string
+        unit: options.unit
       },
   sumExprNormalized: (
     expression: ComputedProjectionMathExpression,
@@ -826,18 +826,18 @@ export const relation = <
     operation
       ? {
         _tag: "relation-sum-expr-normalized",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string,
+        unit: options.unit,
         toBase: options.toBase,
         factors: options.factors,
         operation
       }
       : {
         _tag: "relation-sum-expr-normalized",
-        path: path as string,
+        path,
         expression,
-        unit: options.unit as string,
+        unit: options.unit,
         toBase: options.toBase,
         factors: options.factors
       },
@@ -848,15 +848,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: false,
         operation
       }
       : {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: false
       },
   collectDistinct: <const F extends FieldPath<RelationElement<TFieldValues, P>>>(
@@ -866,15 +866,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: true,
         operation
       }
       : {
         _tag: "relation-collect",
-        path: path as string,
-        field: field as string,
+        path,
+        field,
         distinct: true
       },
   collectFields: <const F extends readonly FieldPath<RelationElement<TFieldValues, P>>[]>(
@@ -886,15 +886,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: false,
         operation
       }
       : {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: false
       },
   collectDistinctFields: <const F extends readonly FieldPath<RelationElement<TFieldValues, P>>[]>(
@@ -906,15 +906,15 @@ export const relation = <
     operation
       ? {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: true,
         operation
       }
       : {
         _tag: "relation-collect-fields",
-        path: path as string,
-        fields: fields as readonly string[],
+        path,
+        fields,
         distinct: true
       }
 })
@@ -930,7 +930,7 @@ export const relation = <
 export const expr = {
   field: <T extends FieldValues = FieldValues>(
     field: FieldPath<T>
-  ): ComputedProjectionMathExpression => ({ _tag: "field", field: field as string }),
+  ): ComputedProjectionMathExpression => ({ _tag: "field", field }),
   mul: (
     left: ComputedProjectionMathExpression,
     right: ComputedProjectionMathExpression
@@ -1059,7 +1059,7 @@ export const projectComputed: {
   const computedProjection = typeof mapOrBuild === "function"
     ? mapOrBuild(makeComputedHelpers())
     : mapOrBuild
-  return new Project({ current, schema, mode, computed: computedProjection } as any)
+  return new Project({ current, schema, mode, computed: computedProjection })
 }
 
 /**
@@ -1077,12 +1077,12 @@ export interface AggBuilder<TFieldValues extends FieldValues> {
 }
 
 const makeAggBuilder = <TFieldValues extends FieldValues>(): AggBuilder<TFieldValues> => ({
-  field: (path) => ({ _tag: "agg-field", path: path as string }),
+  field: (path) => ({ _tag: "agg-field", path }),
   count: () => ({ _tag: "agg-count" }),
   countWhen: (operation) => ({ _tag: "agg-count-when", operation }),
-  sum: (field) => ({ _tag: "agg-sum", field: field as string }),
-  min: (field) => ({ _tag: "agg-min", field: field as string }),
-  max: (field) => ({ _tag: "agg-max", field: field as string })
+  sum: (field) => ({ _tag: "agg-sum", field }),
+  min: (field) => ({ _tag: "agg-min", field }),
+  max: (field) => ({ _tag: "agg-max", field })
 })
 
 /**

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

@@ -316,17 +316,17 @@ const interpret = <
                 case "relation-count":
                 case "relation-any":
                 case "relation-every":
-                  return [key, { _tag: e._tag, path: e.path, filter } as ComputedProjectionIrExpression]
+                  return [key, { _tag: e._tag, path: e.path, filter }]
                 case "relation-distinct-count":
                 case "relation-sum":
                   return [
                     key,
-                    { _tag: e._tag, path: e.path, field: e.field, filter } as ComputedProjectionIrExpression
+                    { _tag: e._tag, path: e.path, field: e.field, filter }
                   ]
                 case "relation-sum-expr":
                   return [
                     key,
-                    { _tag: e._tag, path: e.path, expression: e.expression, filter } as ComputedProjectionIrExpression
+                    { _tag: e._tag, path: e.path, expression: e.expression, filter }
                   ]
                 case "relation-sum-expr-by":
                   return [
@@ -337,7 +337,7 @@ const interpret = <
                       expression: e.expression,
                       unit: e.unit,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-sum-expr-normalized":
                   return [
@@ -350,7 +350,7 @@ const interpret = <
                       toBase: e.toBase,
                       factors: e.factors,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-collect":
                   return [
@@ -361,7 +361,7 @@ const interpret = <
                       field: e.field,
                       distinct: e.distinct,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-collect-fields":
                   return [
@@ -372,10 +372,10 @@ const interpret = <
                       fields: e.fields,
                       distinct: e.distinct,
                       filter
-                    } as ComputedProjectionIrExpression
+                    }
                   ]
                 case "relation-length":
-                  return [key, { _tag: e._tag, path: e.path } as ComputedProjectionIrExpression]
+                  return [key, { _tag: e._tag, path: e.path }]
               }
             })
           )

package/src/Model.ts

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