@effect-app/infra 2.7.0 → 2.8.0

package/src/{services/RepositoryBase.ts → Model/Repository/makeRepo.ts}

@@ -5,26 +5,24 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 // import type { ParserEnv } from "effect-app/Schema/custom/Parser"
-import { type Repository } from "./Repository.js"
-import { StoreMaker } from "./Store.js"
-import type { FilterArgs, PersistenceModelType, StoreConfig } from "./Store.js"
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { Array, Chunk, Context, Effect, Equivalence, flow, Option, pipe, PubSub, S, Unify } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
+import { NotFoundError } from "effect-app/client"
 import { flatMapOption } from "effect-app/Effect"
 import type { Schema } from "effect-app/Schema"
 import { NonNegativeInt } from "effect-app/Schema"
-import { setupRequestContextFromCurrent } from "../api/setupRequest.js"
-import { NotFoundError } from "../errors.js"
+import { setupRequestContextFromCurrent } from "../../api/setupRequest.js"
+import type { FilterArgs, PersistenceModelType, StoreConfig } from "../../Store.js"
+import { StoreMaker } from "../../Store.js"
+import { getContextMap } from "../../Store/ContextMapContainer.js"
 import type { FieldValues } from "../filter/types.js"
-import { make as makeQuery } from "./query.js"
-import type { QAll, QueryProjection } from "./query.js"
-import * as Q from "./query.js"
-import { extendRepo } from "./Repository/ext.js"
-import type { ExtendedRepository } from "./Repository/ext.js"
-import { getContextMap } from "./Store/ContextMapContainer.js"
+import * as Q from "../query.js"
+import type { ExtendedRepository } from "./ext.js"
+import { extendRepo } from "./ext.js"
+import type { Repository } from "./service.js"
 
 const dedupe = Array.dedupeWith(Equivalence.string)
 
@@ -65,7 +63,7 @@ export function makeRepoInternal<
 
     const mkStore = makeStore<Encoded>()(name, schema, mapTo)
 
-    function make<RInitial = never, E = never, R2 = never, RCtx = never>(
+    function make<RInitial = never, E = never, RPublish = never, RCtx = never>(
       args: [Evt] extends [never] ? {
           schemaContext?: Context.Context<RCtx>
           makeInitial?: Effect<readonly T[], E, RInitial>
@@ -75,7 +73,7 @@ export function makeRepoInternal<
         }
         : {
           schemaContext?: Context.Context<RCtx>
-          publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, R2>
+          publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, RPublish>
           makeInitial?: Effect<readonly T[], E, RInitial>
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (a: Encoded) => string
@@ -104,9 +102,8 @@ export function makeRepoInternal<
             set: (id: string, etag: string | undefined) => _.set(`${name}.${id}`, etag)
           }))
 
-          const pubCfg = yield* Effect.context<R2>()
           const pub = "publishEvents" in args
-            ? flow(args.publishEvents, Effect.provide(pubCfg))
+            ? args.publishEvents
             : () => Effect.void
           const changeFeed = yield* PubSub.unbounded<[T[], "save" | "remove"]>()
 
@@ -256,12 +253,12 @@ export function makeRepoInternal<
           // TODO: For raw we should use S.from, and drop the R...
           const query: {
             <A, R, From extends FieldValues>(
-              q: QueryProjection<Encoded extends From ? From : never, A, R>
+              q: Q.QueryProjection<Encoded extends From ? From : never, A, R>
             ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
             <A, R, EncodedRefined extends Encoded = Encoded>(
-              q: QAll<NoInfer<Encoded>, NoInfer<EncodedRefined>, A, R>
+              q: Q.QAll<NoInfer<Encoded>, NoInfer<EncodedRefined>, A, R>
             ): Effect.Effect<readonly A[], never, R>
-          } = (<A, R, EncodedRefined extends Encoded = Encoded>(q: QAll<Encoded, EncodedRefined, A, R>) => {
+          } = (<A, R, EncodedRefined extends Encoded = Encoded>(q: Q.QAll<Encoded, EncodedRefined, A, R>) => {
             const a = Q.toFilter(q)
             const eff = a.mode === "project"
               ? filter(a)
@@ -313,7 +310,7 @@ export function makeRepoInternal<
             )
           }) as any
 
-          const r: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>> = {
+          const r: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish> = {
             changeFeed,
             itemType: name,
             idKey,
@@ -321,7 +318,7 @@ export function makeRepoInternal<
             all,
             saveAndPublish,
             removeAndPublish,
-            query: (q: any) => query(typeof q === "function" ? q(makeQuery()) : q) as any,
+            query: (q: any) => query(typeof q === "function" ? q(Q.make()) : q) as any,
             /**
              * @internal
              */
@@ -446,10 +443,11 @@ export function makeStore<
 export interface Repos<
   T,
   Encoded extends { id: string },
-  R,
+  RSchema,
   Evt,
   ItemType extends string,
-  IdKey extends keyof T
+  IdKey extends keyof T,
+  RPublish
 > {
   make<RInitial = never, E = never, R2 = never>(
     args: [Evt] extends [never] ? {
@@ -465,7 +463,7 @@ export interface Repos<
           partitionValue?: (a: Encoded) => string
         }
       }
-  ): Effect<Repository<T, Encoded, Evt, ItemType, IdKey, R>, E, StoreMaker | RInitial | R2>
+  ): Effect<Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish>, E, StoreMaker | RInitial | R2>
   makeWith<Out, RInitial = never, E = never, R2 = never>(
     args: [Evt] extends [never] ? {
         makeInitial?: Effect<readonly T[], E, RInitial>
@@ -480,10 +478,10 @@ export interface Repos<
           partitionValue?: (a: Encoded) => string
         }
       },
-    f: (r: Repository<T, Encoded, Evt, ItemType, IdKey, R>) => Out
+    f: (r: Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish>) => Out
   ): Effect<Out, E, StoreMaker | RInitial | R2>
   readonly Q: ReturnType<typeof Q.make<Encoded>>
-  readonly type: Repository<T, Encoded, Evt, ItemType, IdKey, R>
+  readonly type: Repository<T, Encoded, Evt, ItemType, IdKey, RSchema, RPublish>
 }
 
 export type GetRepoType<T> = T extends { type: infer R } ? R : never
@@ -491,56 +489,60 @@ export type GetRepoType<T> = T extends { type: infer R } ? R : never
 export const makeRepo: {
   <
     ItemType extends string,
-    R,
+    RSchema,
     Encoded extends { id: string },
     T,
     IdKey extends keyof T,
     E = never,
-    RInitial = never,
-    R2 = never,
     Evt = never,
+    RInitial = never,
+    RPublish = never,
     RCtx = never
   >(
     itemType: ItemType,
-    schema: S.Schema<T, Encoded, R>,
+    schema: S.Schema<T, Encoded, RSchema>,
     options: {
       idKey: IdKey
       jitM?: (pm: Encoded) => Encoded
       config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
         partitionValue?: (a: Encoded) => string
       }
-      publishEvents?: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, R2>
+      publishEvents?: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, RPublish>
       makeInitial?: Effect<readonly T[], E, RInitial>
       schemaContext?: Context.Context<RCtx>
     }
   ): Effect.Effect<
-    ExtendedRepository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>>,
+    ExtendedRepository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>,
     E,
-    RInitial | R2 | StoreMaker
+    RInitial | StoreMaker
   >
   <
     ItemType extends string,
-    R,
+    RSchema,
     Encoded extends { id: string },
     T extends { id: unknown },
     E = never,
-    RInitial = never,
-    R2 = never,
     Evt = never,
+    RInitial = never,
+    RPublish = never,
     RCtx = never
   >(
     itemType: ItemType,
-    schema: S.Schema<T, Encoded, R>,
+    schema: S.Schema<T, Encoded, RSchema>,
     options: {
       jitM?: (pm: Encoded) => Encoded
       config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
         partitionValue?: (a: Encoded) => string
       }
-      publishEvents?: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, R2>
+      publishEvents?: (evt: NonEmptyReadonlyArray<Evt>) => Effect<void, never, RPublish>
       makeInitial?: Effect<readonly T[], E, RInitial>
       schemaContext?: Context.Context<RCtx>
     }
-  ): Effect.Effect<ExtendedRepository<T, Encoded, Evt, ItemType, "id", Exclude<R, RCtx>>, E, RInitial | R2 | StoreMaker>
+  ): Effect.Effect<
+    ExtendedRepository<T, Encoded, Evt, ItemType, "id", Exclude<RSchema, RCtx>, RPublish>,
+    E,
+    RInitial | StoreMaker
+  >
 } = <
   ItemType extends string,
   R,

package/src/{services → Model}/Repository/service.ts

@@ -1,7 +1,7 @@
 import type { Effect, Option, PubSub, S } from "effect-app"
 import type { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "effect-app/client"
 import type { NonNegativeInt } from "effect-app/Schema/numbers"
-import type { FieldValues } from "../../filter/types.js"
+import type { FieldValues } from "../filter/types.js"
 import type { QAll, Query, QueryProjection } from "../query.js"
 import type { Mapped } from "./legacy.js"
 
@@ -14,21 +14,22 @@ export interface Repository<
   Evt,
   ItemType extends string,
   IdKey extends keyof T,
-  R
+  RSchema,
+  RPublish
 > {
   readonly itemType: ItemType
   readonly idKey: IdKey
-  readonly find: (id: T[IdKey]) => Effect<Option<T>, never, R>
-  readonly all: Effect<T[], never, R>
+  readonly find: (id: T[IdKey]) => Effect<Option<T>, never, RSchema>
+  readonly all: Effect<T[], never, RSchema>
   readonly saveAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
-  ) => Effect<void, InvalidStateError | OptimisticConcurrencyException, R>
+  ) => Effect<void, InvalidStateError | OptimisticConcurrencyException, RSchema | RPublish>
   readonly changeFeed: PubSub.PubSub<[T[], "save" | "remove"]>
   readonly removeAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
-  ) => Effect<void, never, R>
+  ) => Effect<void, never, RSchema | RPublish>
 
   readonly query: {
     <A, R, From extends FieldValues, TType extends "one" | "many" | "count" = "many">(
@@ -39,7 +40,7 @@ export interface Repository<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
       | (TType extends "count" ? never : S.ParseResult.ParseError),
-      R
+      R | RSchema
     >
     <
       R = never,
@@ -50,7 +51,7 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly RefineTHelper<T, EncodedRefined>[] : RefineTHelper<T, EncodedRefined>,
       TType extends "many" ? never : NotFoundError<ItemType>,
-      R
+      R | RSchema
     >
   }
   /** @deprecated use query */

package/src/{services → Model}/Repository.ts

@@ -1,4 +1,4 @@
-export * from "./Repository/dsl.js"
 export * from "./Repository/ext.js"
 export * from "./Repository/legacy.js"
+export { makeRepo } from "./Repository/makeRepo.js"
 export * from "./Repository/service.js"

package/src/{services → Model}/query/dsl.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { FieldValues } from "@effect-app/infra/filter/types"
-import type { FieldPath, FieldPathValue } from "@effect-app/infra/filter/types/path/eager"
-import type { Ops } from "@effect-app/infra/services/Store/filterApi/query"
 import type { Option, S } from "effect-app"
 import { Data, flow, Pipeable } from "effect-app"
 import type { NonNegativeInt } from "effect-app/Schema"
 import type { Covariant } from "effect/Types"
+import type { Ops } from "../filter/filterApi.js"
+import type { FieldValues } from "../filter/types.js"
+import type { FieldPath, FieldPathValue } from "../filter/types/path/eager.js"
 
 export type QAll<
   TFieldValues extends FieldValues,
@@ -269,7 +269,13 @@ export const project: {
     A = ExtractFieldValuesRefined<Q>,
     R = never
   >(
-    schema: S.Schema<Option<A>, { [K in keyof I & keyof ExtractFieldValuesRefined<Q>]: I[K] }, R>,
+    schema: S.Schema<
+      Option<A>,
+      {
+        [K in keyof I]: K extends keyof ExtractFieldValuesRefined<Q> ? I[K] : never
+      },
+      R
+    >,
     mode: "collect"
   ): (
     current: Q
@@ -281,7 +287,13 @@ export const project: {
     A = ExtractFieldValuesRefined<Q>,
     R = never
   >(
-    schema: S.Schema<A, { [K in keyof I & keyof ExtractFieldValuesRefined<Q>]: I[K] }, R>,
+    schema: S.Schema<
+      A,
+      {
+        [K in keyof I]: K extends keyof ExtractFieldValuesRefined<Q> ? I[K] : never
+      },
+      R
+    >,
     mode: "project"
   ): (
     current: Q
@@ -292,7 +304,13 @@ export const project: {
     A = ExtractFieldValuesRefined<Q>,
     R = never
   >(
-    schema: S.Schema<A, { [K in keyof I & keyof ExtractFieldValuesRefined<Q>]: I[K] }, R>
+    schema: S.Schema<
+      A,
+      {
+        [K in keyof I]: K extends keyof ExtractFieldValuesRefined<Q> ? I[K] : never
+      },
+      R
+    >
   ): (
     current: Q
   ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>>

package/src/{services → Model}/query/new-kid-interpreter.ts

@@ -3,10 +3,10 @@
 import { Match, Option, pipe, S } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { dropUndefinedT } from "effect-app/utils"
-import type { FieldValues } from "../../filter/types.js"
-import type { FieldPath } from "../../filter/types/path/eager.js"
+import type { FilterResult } from "../filter/filterApi.js"
+import type { FieldValues } from "../filter/types.js"
+import type { FieldPath } from "../filter/types/path/eager.js"
 import { make, type Q, type QAll } from "../query/dsl.js"
-import type { FilterResult } from "../Store/filterApi/query.js"
 
 type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   filter: FilterResult[]

package/src/Model.ts

@@ -1 +1,3 @@
-export { makeRepo } from "./services/RepositoryBase.js"
+export * from "./Model/dsl.js"
+export * as Q from "./Model/query.js"
+export { makeRepo } from "./Model/Repository.js"

package/src/{services/Operations.ts → Operations.ts}

@@ -8,11 +8,11 @@ import type { OperationProgress } from "effect-app/Operations"
 import { Operation, OperationFailure, OperationId, OperationSuccess } from "effect-app/Operations"
 import { NonEmptyString2k } from "effect-app/Schema"
 import * as Scope from "effect/Scope"
-import { setupRequestContextFromCurrent } from "../api/setupRequest.js"
-import { batch } from "../rateLimit.js"
+import { setupRequestContextFromCurrent } from "./api/setupRequest.js"
 import { MainFiberSet } from "./MainFiberSet.js"
+import { where } from "./Model/query.js"
 import { OperationsRepo } from "./OperationsRepo.js"
-import { where } from "./query.js"
+import { batch } from "./rateLimit.js"
 import { RequestFiberSet } from "./RequestFiberSet.js"
 
 const reportAppError = reportError("Operations.Cleanup")

package/src/{services/OperationsRepo.ts → OperationsRepo.ts}

@@ -1,6 +1,6 @@
 import { Effect } from "effect-app"
 import { Operation } from "effect-app/Operations"
-import { makeRepo } from "./RepositoryBase.js"
+import { makeRepo } from "./Model.js"
 
 export class OperationsRepo extends Effect.Service<OperationsRepo>()(
   "OperationRepo",

package/src/{services/QueueMaker → QueueMaker}/SQLQueue.ts

@@ -1,15 +1,15 @@
 import { getRequestContext, setupRequestContext } from "@effect-app/infra/api/setupRequest"
-import { reportNonInterruptedFailure } from "@effect-app/infra/services/QueueMaker/errors"
-import type { QueueBase } from "@effect-app/infra/services/QueueMaker/service"
-import { QueueMeta } from "@effect-app/infra/services/QueueMaker/service"
+import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors"
+import type { QueueBase } from "@effect-app/infra/QueueMaker/service"
+import { QueueMeta } from "@effect-app/infra/QueueMaker/service"
 import { SqlClient } from "@effect/sql"
 import { randomUUID } from "crypto"
 import { subMinutes } from "date-fns"
 import { Effect, Fiber, Option, S, Tracer } from "effect-app"
 import type { NonEmptyString255 } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
-import { InfraLogger } from "../../logger.js"
 import { SQLModel } from "../adapters/SQL.js"
+import { InfraLogger } from "../logger.js"
 
 export const QueueId = S.Number.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type

package/src/{services/QueueMaker → QueueMaker}/memQueue.ts

@@ -1,9 +1,9 @@
 import { Tracer } from "effect"
 import { Effect, Fiber, flow, S } from "effect-app"
 import { pretty } from "effect-app/utils"
-import { getRequestContext, setupRequestContext } from "../../api/setupRequest.js"
-import { InfraLogger } from "../../logger.js"
 import { MemQueue } from "../adapters/memQueue.js"
+import { getRequestContext, setupRequestContext } from "../api/setupRequest.js"
+import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 

package/src/{services/QueueMaker → QueueMaker}/sbqueue.ts

@@ -3,8 +3,6 @@ import { Tracer } from "effect"
 import { Cause, Effect, flow, Layer, S } from "effect-app"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
-import { getRequestContext, setupRequestContext } from "../../api/setupRequest.js"
-import { InfraLogger } from "../../logger.js"
 import {
   LiveSender,
   LiveServiceBusClient,
@@ -12,6 +10,8 @@ import {
   ServiceBusReceiverFactory,
   subscribe
 } from "../adapters/ServiceBus.js"
+import { getRequestContext, setupRequestContext } from "../api/setupRequest.js"
+import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 

package/src/{services/QueueMaker → QueueMaker}/service.ts

@@ -1,5 +1,5 @@
 import type { Effect, NonEmptyReadonlyArray, Scope } from "effect-app"
-import { RequestContext } from "../../RequestContext.js"
+import { RequestContext } from "../RequestContext.js"
 
 export interface QueueBase<Evt, DrainEvt> {
   drain: <DrainE, DrainR>(

package/src/{services/RequestFiberSet.ts → RequestFiberSet.ts}

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { Tracer } from "effect-app"
 import { Context, Effect, Fiber, FiberSet, Option } from "effect-app"
-import { reportRequestError, reportUnknownRequestError } from "../api/reportError.js"
-import { InfraLogger } from "../logger.js"
+import { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
+import { InfraLogger } from "./logger.js"
 
 const getRootParentSpan = Effect.gen(function*() {
   let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(

package/src/{services/Store → Store}/Cosmos/query.ts

@@ -2,8 +2,8 @@
 import { Array, Effect, Equivalence, pipe } from "effect-app"
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { assertUnreachable } from "effect-app/utils"
-import { InfraLogger } from "../../../logger.js"
-import type { FilterR, FilterResult } from "../filterApi/query.js"
+import { InfraLogger } from "../../logger.js"
+import type { FilterR, FilterResult } from "../../Model/filter/filterApi.js"
 import type { SupportedValues } from "../service.js"
 
 export function logQuery(q: {

package/src/{services/Store → Store}/Cosmos.ts

@@ -4,9 +4,9 @@ import { Array, Chunk, Duration, Effect, Layer, Option, pipe, Secret, Struct } f
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { dropUndefinedT } from "effect-app/utils"
-import { OptimisticConcurrencyException } from "../../errors.js"
-import { InfraLogger } from "../../logger.js"
 import { CosmosClient, CosmosClientLayer } from "../adapters/cosmos-client.js"
+import { OptimisticConcurrencyException } from "../errors.js"
+import { InfraLogger } from "../logger.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { StoreMaker } from "./service.js"
 import type { FilterArgs, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"

package/src/{services/Store → Store}/Disk.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as fu from "../../fileUtil.js"
+import * as fu from "../fileUtil.js"
 
 import fs from "fs"
 

package/src/{services/Store → Store}/Memory.ts

@@ -4,7 +4,7 @@ import { Array, Effect, FiberRef, flow, Option, Order, pipe, Ref, Struct } from
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import { get } from "effect-app/utils"
-import { InfraLogger } from "../../logger.js"
+import { InfraLogger } from "../logger.js"
 import { codeFilter } from "./codeFilter.js"
 import type { FilterArgs, PersistenceModelType, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"

package/src/{services/Store → Store}/codeFilter.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { Array, Option } from "effect-app"
 import { assertUnreachable, get } from "effect-app/utils"
-import type { FilterR, FilterResult } from "./filterApi/query.js"
+import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
 import type { Filter } from "./service.js"
 import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
 

package/src/{services/Store → Store}/service.ts

@@ -2,10 +2,10 @@
 import type { UniqueKey } from "@azure/cosmos"
 import { Context, Effect } from "effect-app"
 import type { NonEmptyReadonlyArray, Option, Secret } from "effect-app"
-import type { OptimisticConcurrencyException } from "../../errors.js"
-import type { FieldValues } from "../../filter/types.js"
-import type { FieldPath } from "../../filter/types/path/index.js"
-import type { FilterResult } from "./filterApi/query.js"
+import type { OptimisticConcurrencyException } from "../errors.js"
+import type { FilterResult } from "../Model/filter/filterApi.js"
+import type { FieldValues } from "../Model/filter/types.js"
+import type { FieldPath } from "../Model/filter/types/path/index.js"
 
 export type StoreConfig<E> = {
   uniqueKeys?: UniqueKey[]

package/src/{services/Store → Store}/utils.ts

@@ -1,6 +1,6 @@
 import { Effect, Option } from "effect-app"
 import objectHash from "object-hash"
-import { OptimisticConcurrencyException } from "../../errors.js"
+import { OptimisticConcurrencyException } from "../errors.js"
 import type { PersistenceModelType, SupportedValues2 } from "./service.js"
 
 export const makeETag = <E extends PersistenceModelType<{}>>(

package/src/api/setupRequest.ts

@@ -1,8 +1,8 @@
 import { Effect, FiberRef, Layer, Tracer } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import { LocaleRef, RequestContext, spanAttributes } from "../RequestContext.js"
-import { startContextMap } from "../services/Store/ContextMapContainer.js"
-import { storeId } from "../services/Store/Memory.js"
+import { startContextMap } from "../Store/ContextMapContainer.js"
+import { storeId } from "../Store/Memory.js"
 
 export const getRequestContext = Effect
   .all({

package/src/logger/shared.ts

@@ -2,7 +2,7 @@ import { Context, FiberRef, Option, Tracer } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import * as FiberRefs from "effect/FiberRefs"
 import { LocaleRef, RequestContext } from "../RequestContext.js"
-import { storeId } from "../services/Store/Memory.js"
+import { storeId } from "../Store/Memory.js"
 
 export function getRequestContextFromFiberRefs(fiberRefs: FiberRefs.FiberRefs) {
   const context = FiberRefs.getOrDefault(fiberRefs, FiberRef.currentContext)

package/src/test.ts

@@ -2,7 +2,7 @@ import { Arbitrary } from "effect"
 import { Predicate, S } from "effect-app"
 import { copy } from "effect-app/utils"
 import type { PropertySignature } from "effect/Schema"
-import { generate } from "./test/arbs.js"
+import { generate } from "./arbs.js"
 
 const isPropertySignature = (u: unknown): u is PropertySignature.All =>
   Predicate.hasProperty(u, S.PropertySignatureTypeId)
@@ -49,4 +49,4 @@ export const createRandomInstanceI = <A extends object, I>(s: S.Schema<A, I, nev
   }
 }
 
-export * from "./test/arbs.js"
+export * from "./arbs.js"

package/test/dist/query.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYlF,qBAAa,SAAU,SAAQ,cAK7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAAgE;CAAG"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAalF,qBAAa,SAAU,SAAQ,cAK7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAAgE;CAAG"}

package/test/query.test.ts

@@ -3,10 +3,11 @@
 import { Context, Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
-import type { QueryEnd, QueryProjection, QueryWhere } from "../src/services/query.js"
-import { and, count, make, one, or, order, page, project, toFilter, where } from "../src/services/query.js"
-import { makeRepo } from "../src/services/RepositoryBase.js"
-import { memFilter, MemoryStoreLive } from "../src/services/Store/Memory.js"
+import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
+import type { QueryEnd, QueryProjection, QueryWhere } from "../src/Model/query.js"
+import { and, count, make, one, or, order, page, project, toFilter, where } from "../src/Model/query.js"
+import { makeRepo } from "../src/Model/Repository.js"
+import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
 const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
@@ -226,7 +227,7 @@ it(
         expect(result).toEqual([])
         expect(result2).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), Effect.runPromise)
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -408,3 +409,29 @@ it(
       })
       .pipe(Effect.runPromise)
 )
+
+it(
+  "project",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          createdAt: S
+            .optional(S.Date)
+            .pipe(
+              S.withDefaults({ constructor: () => new Date(), decoding: () => new Date() })
+            )
+        })
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {}
+        )
+
+        const result = yield* repo.query(flow(where("id", "123"), project(schema)))
+
+        expect(result).toEqual([])
+      })
+      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+)