@effect-app/infra 4.0.0-beta.247 → 4.0.0-beta.249

package/src/Store/SQL.ts

@@ -3,7 +3,10 @@
 import type { NonEmptyReadonlyArray } from "effect-app/Array"
 import { toNonEmptyArray } from "effect-app/Array"
 import * as Effect from "effect-app/Effect"
+import type { FieldValues } from "effect-app/Model/filter/types"
+import type { ComputedProjectionIrExpression } from "effect-app/Model/query"
 import * as Option from "effect-app/Option"
+import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "effect-app/Store"
 import * as Context from "effect/Context"
 import * as Layer from "effect/Layer"
 import * as LayerMap from "effect/LayerMap"
@@ -11,11 +14,8 @@ import * as Struct from "effect/Struct"
 import { SqlClient } from "effect/unstable/sql"
 import { OptimisticConcurrencyException } from "../errors.js"
 import { InfraLogger } from "../logger.js"
-import type { FieldValues } from "../Model/filter/types.js"
-import type { ComputedProjectionIrExpression } from "../Model/query.js"
 import { annotateDb, type DbSystem } from "../otel.js"
 import { storeId } from "./Memory.js"
-import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "./service.js"
 import { buildWhereSQLQuery, logQuery, type SQLDialect, sqliteDialect } from "./SQL/query.js"
 import { makeETag } from "./utils.js"
 

package/src/Store/codeFilter.ts

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import * as Array from "effect-app/Array"
+import type { FilterR, FilterResult } from "effect-app/Model/filter/filterApi"
+import type { FieldValues } from "effect-app/Model/filter/types"
 import * as Option from "effect-app/Option"
+import type { Filter } from "effect-app/Store"
 import { assertUnreachable } from "effect-app/utils"
-import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
-import type { FieldValues } from "../Model/filter/types.js"
 import { get } from "./Memory.js"
-import type { Filter } from "./service.js"
 import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
 
 const vAsArr = (v: string) => v as unknown as any[]

package/src/Store/index.ts

@@ -1,14 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
+import { RepositoryRegistryLive } from "effect-app/Model"
+import type { StorageConfig } from "effect-app/Store"
 import * as Redacted from "effect/Redacted"
 import type { SqlClient } from "effect/unstable/sql"
 import { CosmosStoreLayer } from "./Cosmos.js"
 import { DiskStoreLayer } from "./Disk.js"
 import { MemoryStoreLive } from "./Memory.js"
 // import { RedisStoreLayer } from "./Redis.js"
-import { RepositoryRegistryLive } from "../Model.js"
-import type { StorageConfig } from "./service.js"
 import { SQLiteStoreLayer } from "./SQL.js"
 import { PgStoreLayer } from "./SQL/Pg.js"
 
@@ -46,5 +46,3 @@ export function StoreMakerLayer(
     })
     .pipe(Layer.unwrap, Layer.merge(RepositoryRegistryLive))
 }
-
-export * from "./service.js"

package/src/Store/utils.ts

@@ -1,8 +1,8 @@
 import crypto from "crypto"
 import * as Effect from "effect-app/Effect"
 import * as Option from "effect-app/Option"
+import type { PersistenceModelType, SupportedValues2 } from "effect-app/Store"
 import { OptimisticConcurrencyException } from "../errors.js"
-import type { PersistenceModelType, SupportedValues2 } from "./service.js"
 
 export const makeETag = <E extends PersistenceModelType<{}>>(
   { _etag, ...e }: E

package/src/errorReporter.ts

@@ -3,9 +3,9 @@ import * as Effect from "effect-app/Effect"
 import { dropUndefined, LogLevelToSentry } from "effect-app/utils"
 import * as Cause from "effect/Cause"
 import type * as LogLevel from "effect/LogLevel"
-import { getRC } from "./api/setupRequest.js"
 import { CauseException, tryToJson, tryToReport } from "./errors.js"
 import { InfraLogger } from "./logger.js"
+import { getRC } from "./setupRequest.js"
 
 const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): CauseException<E> => {
   try {

package/src/index.ts

@@ -1 +1,2 @@
-export * as Model from "./Model.js"
+export * from "./logger.js"
+export * from "./Store/index.js"

package/src/{api/internal → internal}/RequestContextMiddleware.ts

@@ -1,11 +1,11 @@
 import * as Effect from "effect-app/Effect"
 import { HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect-app/http"
 import * as Layer from "effect-app/Layer"
+import { Locale, LocaleRef, RequestContext, spanAttributes } from "effect-app/RequestContext"
 import { NonEmptyString255 } from "effect-app/Schema"
-import { Locale, LocaleRef, RequestContext, spanAttributes } from "../../RequestContext.js"
-import { ContextMapContainer } from "../../Store/ContextMapContainer.js"
-import { storeId } from "../../Store/Memory.js"
 import { provideOnRequestScope } from "../setupRequest.js"
+import { ContextMapContainer } from "../Store/ContextMapContainer.js"
+import { storeId } from "../Store/Memory.js"
 
 export const RequestContextMiddleware = (defaultLocale: Locale = "en") =>
   HttpMiddleware.make((app) =>

package/src/{api/internal → internal}/events.ts

@@ -5,9 +5,9 @@ import * as Duration from "effect/Duration"
 import { pipe } from "effect/Function"
 import * as Schedule from "effect/Schedule"
 import * as Stream from "effect/Stream"
-import { reportError } from "../../errorReporter.js"
-import { storeId } from "../../Store/Memory.js"
+import { reportError } from "../errorReporter.js"
 import { setupStreamingRequestContextFromCurrent } from "../setupRequest.js"
+import { storeId } from "../Store/Memory.js"
 
 // Tell the client to retry every 10 seconds if connectivity is lost
 const setRetry = Stream.succeed("retry: 10000")

package/src/{api/layerUtils.ts → layerUtils.ts}

@@ -4,7 +4,7 @@ import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import type * as Layer from "effect-app/Layer"
 import * as Option from "effect-app/Option"
-import { InfraLogger } from "../logger.js"
+import { InfraLogger } from "./logger.js"
 
 // TODO: These LayerUtils are flaky, like in dependencies as a readonly array, it breaks when there are two entries
 // we should look at Service.MakeDeps[E/RIn/ROut] etc.

package/src/logger/jsonLogger.ts

@@ -1,8 +1,8 @@
 import * as Array from "effect-app/Array"
+import { spanAttributes } from "effect-app/RequestContext"
 import * as Cause from "effect/Cause"
 import * as Logger from "effect/Logger"
 import { CurrentLogAnnotations, CurrentLogSpans } from "effect/References"
-import { spanAttributes } from "../RequestContext.js"
 import { getRequestContextFromFiber } from "./shared.js"
 
 export const jsonLogger = Logger.make<unknown, void>(

package/src/logger/logFmtLogger.ts

@@ -1,5 +1,5 @@
+import { spanAttributes } from "effect-app/RequestContext"
 import * as Logger from "effect/Logger"
-import { spanAttributes } from "../RequestContext.js"
 import { getRequestContextFromFiber } from "./shared.js"
 
 export const logfmtLogger = Logger.make<unknown, void>(

package/src/logger/shared.ts

@@ -1,7 +1,7 @@
 import * as Option from "effect-app/Option"
+import { LocaleRef, RequestContext } from "effect-app/RequestContext"
 import { NonEmptyString255 } from "effect-app/Schema"
 import type * as Fiber from "effect/Fiber"
-import { LocaleRef, RequestContext } from "../RequestContext.js"
 import { storeId } from "../Store/Memory.js"
 
 export function getRequestContextFromFiber(fiber: Fiber.Fiber<unknown, unknown>) {

package/src/{adapters/redis-client.ts → redis-client.ts}

@@ -8,7 +8,7 @@ import Redlock from "redlock"
 
 export class ConnectionException extends Data.TaggedError("ConnectionException")<{ cause: Error; message: string }> {
   constructor(cause: Error) {
-    super({ message: "A connection error ocurred", cause })
+    super({ message: "A connection error occurred", cause })
   }
 }
 

package/src/{api/reportError.ts → reportError.ts}

@@ -1,6 +1,6 @@
 import * as Effect from "effect-app/Effect"
 import * as Cause from "effect/Cause"
-import { logError, reportError } from "../errorReporter.js"
+import { logError, reportError } from "./errorReporter.js"
 
 // const onExitReportError = (name: string, unknownOnly?: boolean) => {
 //   const report = reportError(name)

package/src/{api/routing → routing}/middleware/middleware.ts

@@ -10,9 +10,9 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Schema from "effect/Schema"
 import { type Rpc } from "effect/unstable/rpc"
-import { logError, reportError } from "../../../errorReporter.js"
-import { InfraLogger } from "../../../logger.js"
-import { WithNsTransaction } from "../../../Store/SQL.js"
+import { logError, reportError } from "../../errorReporter.js"
+import { InfraLogger } from "../../logger.js"
+import { WithNsTransaction } from "../../Store/SQL.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
@@ -35,7 +35,7 @@ const isOptimisticConcurrencyException = (input: unknown) =>
   typeof input === "object" && input !== null && "_tag" in input && input._tag === "OptimisticConcurrencyException"
 
 export const RequestType = Context.Reference<"command" | "query">(
-  "@effect-app/infra/api/routing/RequestType",
+  "@effect-app/infra/routing/RequestType",
   { defaultValue: () => "query" }
 )
 

package/src/{api/routing.ts → routing.ts}

@@ -73,8 +73,8 @@ type GetSuccess<T> = T extends { success: S.Top } ? T["success"] : typeof S.Void
 type GetFailure<T extends { error?: S.Top }> = T["error"] extends never ? typeof S.Never : T["error"]
 
 type GetSuccessShape<Action extends { success?: S.Top }, RT extends RequestType> = {
-  d: S.Schema.Type<GetSuccess<Action>>
-  raw: S.Codec.Encoded<GetSuccess<Action>>
+  d: GetSuccess<Action>["Type"]
+  raw: GetSuccess<Action>["Encoded"]
 }[RT]
 
 interface HandlerBase<Action extends AnyRequestModule, RT extends RequestType, A, E, R> {
@@ -82,7 +82,7 @@ interface HandlerBase<Action extends AnyRequestModule, RT extends RequestType, A
   _tag: RT
   stack: string
   handler: (
-    req: S.Schema.Type<Action>,
+    req: Action["Type"],
     headers: HttpHeaders.Headers
   ) => Effect.Effect<A, E, R> | Stream.Stream<A, E, R>
 }
@@ -92,7 +92,7 @@ export interface Handler<Action extends AnyRequestModule, RT extends RequestType
     Action,
     RT,
     GetSuccessShape<Action, RT>,
-    S.Schema.Type<GetFailure<Action>> | S.SchemaError,
+    GetFailure<Action>["Type"] | S.SchemaError,
     R
   >
 {}
@@ -123,7 +123,7 @@ type EffectMatch<
   RT extends RequestType,
   Key extends keyof Resource
 > = <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
-  f: (req: S.Schema.Type<Resource[Key]>) => Effect.Effect<A, E, R2>
+  f: (req: Resource[Key]["Type"]) => Effect.Effect<A, E, R2>
 ) => Handler<
   Resource[Key],
   RT,
@@ -139,7 +139,7 @@ type StreamMatch<
   RT extends RequestType,
   Key extends keyof Resource
 > = <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
-  f: (req: S.Schema.Type<Resource[Key]>) => Stream.Stream<A, E, R2>
+  f: (req: Resource[Key]["Type"]) => Stream.Stream<A, E, R2>
 ) => Handler<
   Resource[Key],
   RT,
@@ -171,7 +171,7 @@ export type RouteMatcher<
     & Match<Resource, RequestContextMap, RequestTypes.DECODED, Key>
     & {
       success: Resource[Key]["success"]
-      successRaw: S.Codec<S.Codec.Encoded<Resource[Key]["success"]>>
+      successRaw: S.Codec<Resource[Key]["success"]["Encoded"]>
       error: Resource[Key]["error"]
       /**
        * Requires the Encoded shape (e.g directly undecoded from DB, so that we don't do multiple Decode/Encode)
@@ -266,11 +266,11 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
       Action extends AnyRequestModule,
       RT extends RequestType
     > = (
-      req: S.Schema.Type<Action>
+      req: Action["Type"]
     ) => Generator<
       Effect.Effect<
         any,
-        S.Schema.Type<GetFailure<Action>> | S.SchemaError,
+        GetFailure<Action>["Type"] | S.SchemaError,
         // the actual implementation of the handler may just require the dynamic context provided by the middleware
         // and the per request context provided by the context provider
         HandlerContext<Action>
@@ -283,10 +283,10 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
       Action extends AnyRequestModule,
       RT extends RequestType
     > = (
-      req: S.Schema.Type<Action>
+      req: Action["Type"]
     ) => Effect.Effect<
       GetSuccessShape<Action, RT>,
-      S.Schema.Type<GetFailure<Action>> | S.SchemaError,
+      GetFailure<Action>["Type"] | S.SchemaError,
       // the actual implementation of the handler may just require the dynamic context provided by the middleware
       // and the per request context provided by the context provider
       HandlerContext<Action>
@@ -296,10 +296,10 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
       Action extends AnyRequestModule,
       RT extends RequestType
     > = (
-      req: S.Schema.Type<Action>
+      req: Action["Type"]
     ) => Stream.Stream<
       GetSuccessShape<Action, RT>,
-      S.Schema.Type<GetFailure<Action>> | S.SchemaError,
+      GetFailure<Action>["Type"] | S.SchemaError,
       HandlerContext<Action>
     >
 

package/src/{api/setupRequest.ts → setupRequest.ts}

@@ -1,12 +1,12 @@
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
 import * as Option from "effect-app/Option"
+import { LocaleRef, RequestContext, spanAttributes } from "effect-app/RequestContext"
 import { NonEmptyString255 } from "effect-app/Schema"
 import * as Tracer from "effect/Tracer"
 import { SqlClient } from "effect/unstable/sql"
-import { LocaleRef, RequestContext, spanAttributes } from "../RequestContext.js"
-import { ContextMapContainer } from "../Store/ContextMapContainer.js"
-import { storeId } from "../Store/Memory.js"
+import { ContextMapContainer } from "./Store/ContextMapContainer.js"
+import { storeId } from "./Store/Memory.js"
 
 const withSqlTransaction = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.serviceOption(SqlClient.SqlClient).pipe(

package/test/auth.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect-app/Effect"
 import { HttpHeaders } from "effect-app/http"
 import { SignJWT } from "jose"
-import { checkJWTI, InvalidRequestError, InvalidTokenError, UnauthorizedError } from "../src/api/internal/auth.js"
+import { checkJWTI, InvalidRequestError, InvalidTokenError, UnauthorizedError } from "../src/internal/auth.js"
 
 const issuer = "https://issuer.example.com/"
 const audience = "effect-app"

package/test/contextProvider.test.ts

@@ -5,7 +5,7 @@ import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
 import * as Scope from "effect/Scope"
-import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
+import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off

package/test/controller.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
+import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/routing"
 import { expect, expectTypeOf, it } from "@effect/vitest"
 import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
 import * as Context from "effect-app/Context"
@@ -13,8 +13,8 @@ import * as S from "effect-app/Schema"
 import { TypeTestId } from "effect-app/TypeTest"
 import * as Scope from "effect/Scope"
 import { type RpcSerialization } from "effect/unstable/rpc"
-import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/api/routing/middleware.js"
-import { sort } from "../src/api/routing/tsort.js"
+import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/routing/middleware.js"
+import { sort } from "../src/routing/tsort.js"
 import { AllowAnonymous, AllowAnonymousLive, CustomError1, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
 
 class MyContextProvider extends RpcX.RpcMiddleware.Tag<MyContextProvider, {

package/test/cosmos-query.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { and, computed, make, projectComputed, relation, toFilter, where } from "effect-app/Model/query"
 import * as S from "effect-app/Schema"
 import { describe, expect, it } from "vitest"
-import { and, computed, make, projectComputed, relation, toFilter, where } from "../src/Model/query.js"
 import { buildWhereCosmosQuery3 } from "../src/Store/Cosmos/query.js"
 
 class Order extends S.Class<Order>("Order")({

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

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,CAAC,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;;;;;AAmBtC,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC,CAAC;IAElC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACtE"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,CAAC,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;;;;;AAgBtC,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC,CAAC;IAElC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACtE"}

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

@@ -1 +1 @@
-{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAA;AAavD,eAAO,MAAM,EAAE,6CAWb,CAAA"}
+{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAA;AAUvD,eAAO,MAAM,EAAE,6CAWb,CAAA"}

package/test/layerUtils.test.ts

@@ -1,6 +1,6 @@
 import { expectTypeOf, it } from "@effect/vitest"
 import type * as Layer from "effect/Layer"
-import { type LayerUtils } from "../src/api/layerUtils.js"
+import { type LayerUtils } from "../src/layerUtils.js"
 
 it("works", () => {
   // not supported atm, resolves to unknown!

package/test/query.test.ts

@@ -4,6 +4,9 @@
 import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
+import { and, computed, count, expr, make, one, or, order, page, project, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "effect-app/Model/query"
+import { makeRepo } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
 import * as Option from "effect-app/Option"
 import * as S from "effect-app/Schema"
 import { flow, pipe } from "effect/Function"
@@ -11,10 +14,7 @@ import * as SchemaTransformation from "effect/SchemaTransformation"
 import * as Struct from "effect/Struct"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, computed, count, expr, make, one, or, order, page, project, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "../src/Model/query.js"
-import { makeRepo } from "../src/Model/Repository.js"
-import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
+import { setupRequestContextFromCurrent } from "../src/setupRequest.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 import { SomeService } from "./fixtures.js"
 

package/test/rawQuery.test.ts

@@ -5,6 +5,9 @@ import * as Config from "effect-app/Config"
 import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
+import { and, computed, or, project, projectComputed, relation, where, whereEvery, whereSome } from "effect-app/Model/query"
+import { makeRepo } from "effect-app/Model/Repository/makeRepo"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
 import * as S from "effect-app/Schema"
 import { LogLevels } from "effect-app/utils"
 import { flow } from "effect/Function"
@@ -13,10 +16,7 @@ import * as Redacted from "effect/Redacted"
 import * as References from "effect/References"
 import * as Result from "effect/Result"
 import * as Struct from "effect/Struct"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, computed, or, project, projectComputed, relation, where, whereEvery, whereSome } from "../src/Model/query.js"
-import { makeRepo } from "../src/Model/Repository/makeRepo.js"
-import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
+import { setupRequestContextFromCurrent } from "../src/setupRequest.js"
 import { CosmosStoreLayer } from "../src/Store/Cosmos.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 import { SQLiteStoreLayer } from "../src/Store/SQL.js"

package/test/repository-ext.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
+import { makeRepo } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
 import * as S from "effect-app/Schema"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { makeRepo } from "../src/Model/Repository.js"
-import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
+import { setupRequestContextFromCurrent } from "../src/setupRequest.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 
 class BatchItem extends S.Class<BatchItem>("BatchItem")({

package/test/router-generator.test.ts

@@ -1,11 +1,11 @@
-import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
-import { makeAllDSL, makeOneDSL } from "@effect-app/infra/Model"
+import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/routing"
 import { expectTypeOf, it } from "@effect/vitest"
 import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
 import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { makeAllDSL, makeOneDSL } from "effect-app/Model"
 import { type FixEnv } from "effect-app/Pure"
 import * as RpcX from "effect-app/rpc"
 import { MiddlewareMaker } from "effect-app/rpc"
@@ -13,7 +13,7 @@ import * as S from "effect-app/Schema"
 import { type TypeTestId } from "effect-app/TypeTest"
 import { type ConfigError } from "effect/Config"
 import { type RpcSerialization } from "effect/unstable/rpc/RpcSerialization"
-import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/api/routing/middleware.js"
+import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/routing/middleware.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
 
 // Inline minimal context provider (provides `Some`)

package/test/routing-interruptibility.test.ts

@@ -6,8 +6,8 @@ import * as Fiber from "effect/Fiber"
 import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
 import { Rpc, RpcGroup, RpcTest } from "effect/unstable/rpc"
-import { applyRequestTypeInterruptibility } from "../src/api/routing.js"
-import { ConfigureInterruptibilityMiddlewareLive, RequestType } from "../src/api/routing/middleware.js"
+import { applyRequestTypeInterruptibility } from "../src/routing.js"
+import { ConfigureInterruptibilityMiddlewareLive, RequestType } from "../src/routing/middleware.js"
 
 const InterruptibilityRpcs = RpcGroup.make(
   Rpc

package/test/rpc-context-map-streaming.test.ts

@@ -49,9 +49,9 @@ import * as Stream from "effect/Stream"
 import { FetchHttpClient } from "effect/unstable/http"
 import { RpcSerialization } from "effect/unstable/rpc"
 import { createServer } from "http"
-import { RequestContextMiddleware } from "../src/api/internal/RequestContextMiddleware.js"
-import { makeRouter } from "../src/api/routing.js"
-import { DefaultGenericMiddlewaresLive } from "../src/api/routing/middleware.js"
+import { RequestContextMiddleware } from "../src/internal/RequestContextMiddleware.js"
+import { makeRouter } from "../src/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
 import { getContextMap } from "../src/Store/ContextMapContainer.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
 

package/test/rpc-e2e-invalidation.test.ts

@@ -29,8 +29,8 @@ import * as Stream from "effect/Stream"
 import { FetchHttpClient } from "effect/unstable/http"
 import { RpcSerialization } from "effect/unstable/rpc"
 import { createServer } from "http"
-import { makeRouter } from "../src/api/routing.js"
-import { DefaultGenericMiddlewaresLive } from "../src/api/routing/middleware.js"
+import { makeRouter } from "../src/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
 
 // ---------------------------------------------------------------------------

package/test/rpc-multi-middleware.test.ts

@@ -14,7 +14,7 @@ import * as Result from "effect/Result"
 import { FetchHttpClient } from "effect/unstable/http"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
 import { createServer } from "http"
-import { DefaultGenericMiddlewaresLive } from "../src/api/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive, UserProfile } from "./fixtures.js"
 
 const incomplete = RpcX

package/test/rpc-stream-fullstack.test.ts

@@ -25,8 +25,8 @@ import * as Stream from "effect/Stream"
 import { FetchHttpClient } from "effect/unstable/http"
 import { RpcSerialization } from "effect/unstable/rpc"
 import { createServer } from "http"
-import { makeRouter } from "../src/api/routing.js"
-import { DefaultGenericMiddlewaresLive } from "../src/api/routing/middleware.js"
+import { makeRouter } from "../src/routing.js"
+import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
 
 // ---------------------------------------------------------------------------

package/test/validateSample.test.ts

@@ -1,10 +1,10 @@
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
+import { makeRepo, ValidationError, ValidationResult } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
 import * as S from "effect-app/Schema"
 import { describe, expect, it } from "vitest"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { makeRepo, ValidationError, ValidationResult } from "../src/Model/Repository.js"
-import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
+import { setupRequestContextFromCurrent } from "../src/setupRequest.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 
 const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)