@effect-app/infra 4.0.0-beta.26 → 4.0.0-beta.260

package/test/cluster-servicebus.test.ts

@@ -0,0 +1,180 @@
+import type { ServiceBusMessage, ServiceBusReceiverOptions } from "@azure/service-bus"
+import { assert, describe, it } from "@effect/vitest"
+import { Context, Effect, Layer, Option, Schema, Stream } from "effect"
+import { ClusterSchema, EntityAddress, EntityId, EntityType, Envelope, Message, MessageStorage, Runners, ShardId, Sharding, ShardingConfig, Snowflake } from "effect/unstable/cluster"
+import { Headers } from "effect/unstable/http"
+import { Rpc } from "effect/unstable/rpc"
+import { type ClusterServiceBusClient, layerClientFrom, layerRunners, makeStoragePoller } from "../src/ClusterServiceBus.js"
+
+describe("ClusterServiceBus", () => {
+  it.effect("wakes storage polling from topic notifications", () =>
+    Effect.gen(function*() {
+      let processMessage: (() => Promise<void>) | undefined
+      let polls = 0
+      let receiverClosed = false
+      let subscriptionClosed = false
+
+      const client: ClusterServiceBusClient = {
+        createSender() {
+          throw new Error("unused")
+        },
+        createReceiver(topicName: string, subscriptionName: string, options?: ServiceBusReceiverOptions) {
+          assert.strictEqual(topicName, "cluster-notifications")
+          assert.strictEqual(subscriptionName, "runner-a")
+          assert.strictEqual(options?.receiveMode, "receiveAndDelete")
+          return {
+            subscribe(handlers) {
+              processMessage = handlers.processMessage
+              return {
+                close() {
+                  subscriptionClosed = true
+                  return Promise.resolve()
+                }
+              }
+            },
+            close() {
+              receiverClosed = true
+              return Promise.resolve()
+            }
+          }
+        },
+        close() {
+          return Promise.resolve()
+        }
+      }
+
+      const sharding = Sharding.Sharding.of({
+        activeEntityCount: Effect.succeed(0),
+        getRegistrationEvents: Stream.empty,
+        getShardId: () => ShardId.make("cluster-servicebus", 0),
+        getSnowflake: Effect.succeed(Snowflake.Snowflake(1n)),
+        hasShardId: () => false,
+        isShutdown: Effect.succeed(false),
+        makeClient: () => Effect.die("unused"),
+        notify: () => Effect.void,
+        pollStorage: Effect.sync(() => {
+          polls++
+        }),
+        registerEntity: () => Effect.void,
+        registerSingleton: () => Effect.void,
+        reset: () => Effect.succeed(false),
+        send: () => Effect.void,
+        sendOutgoing: () => Effect.void
+      })
+
+      yield* Effect
+        .scoped(
+          makeStoragePoller({
+            topicName: "cluster-notifications",
+            subscriptionName: "runner-a"
+          })
+            .pipe(
+              Effect.andThen(
+                Effect.gen(function*() {
+                  if (processMessage === undefined) {
+                    return yield* Effect.die("missing Service Bus subscription")
+                  }
+                  const runProcessMessage = processMessage
+                  yield* Effect.promise(() => runProcessMessage())
+                  assert.strictEqual(polls, 1)
+                })
+              )
+            )
+        )
+        .pipe(
+          Effect.provide(layerClientFrom(client)),
+          Effect.provide(Layer.succeed(Sharding.Sharding)(sharding))
+        )
+
+      assert.strictEqual(subscriptionClosed, true)
+      assert.strictEqual(receiverClosed, true)
+    }))
+
+  it.effect("publishes persisted storage notifications", () =>
+    Effect.gen(function*() {
+      const sent: Array<ServiceBusMessage> = []
+      let senderClosed = false
+
+      const client: ClusterServiceBusClient = {
+        createSender(topicName) {
+          assert.strictEqual(topicName, "cluster-notifications")
+          return {
+            sendMessages(message) {
+              sent.push(message)
+              return Promise.resolve()
+            },
+            close() {
+              senderClosed = true
+              return Promise.resolve()
+            }
+          }
+        },
+        createReceiver() {
+          throw new Error("unused")
+        },
+        close() {
+          return Promise.resolve()
+        }
+      }
+
+      yield* Effect.scoped(
+        Effect
+          .gen(function*() {
+            const runners = yield* Runners.Runners
+            yield* runners.notify({
+              address: Option.none(),
+              discard: true,
+              message: yield* makeOutgoingRequest
+            })
+          })
+          .pipe(
+            Effect.provide(layerRunners({ topicName: "cluster-notifications" })),
+            Effect.provide(layerClientFrom(client)),
+            Effect.provide(MessageStorage.layerNoop),
+            Effect.provide(ShardingConfig.layerDefaults)
+          )
+      )
+
+      assert.strictEqual(senderClosed, true)
+      assert.strictEqual(sent.length, 1)
+      assert.deepStrictEqual(sent[0]?.body, {
+        _tag: "EffectClusterStorageNotification",
+        envelopeId: "1",
+        requestId: "1",
+        shardId: "cluster-servicebus:1",
+        entityType: "TestEntity",
+        entityId: "entity-1"
+      })
+      assert.strictEqual(sent[0]?.contentType, "application/json")
+      assert.strictEqual(sent[0]?.correlationId, "1")
+      assert.strictEqual(sent[0]?.messageId, "1")
+      assert.strictEqual(sent[0]?.subject, "EffectClusterStorageNotification")
+    }))
+})
+
+const TestRpc = Rpc
+  .make("TestRpc", {
+    payload: { id: Schema.Number }
+  })
+  .annotate(ClusterSchema.Persisted, true)
+
+const makeOutgoingRequest = Effect.sync(() =>
+  new Message.OutgoingRequest({
+    annotations: TestRpc.annotations,
+    context: Context.empty(),
+    envelope: Envelope.makeRequest<typeof TestRpc>({
+      address: EntityAddress.make({
+        entityId: EntityId.make("entity-1"),
+        entityType: EntityType.make("TestEntity"),
+        shardId: ShardId.make("cluster-servicebus", 1)
+      }),
+      headers: Headers.empty,
+      payload: { id: 1 },
+      requestId: Snowflake.Snowflake(1n),
+      tag: TestRpc._tag
+    }),
+    lastReceivedReply: Option.none(),
+    respond: () => Effect.void,
+    rpc: TestRpc
+  })
+)

package/test/contextProvider.test.ts

@@ -1,12 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Scope, ServiceMap } from "effect-app"
-import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
+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/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
+class MyContextProvider extends Context.Service<MyContextProvider>()(
   "MyContextProvider",
   {
     make: Effect.gen(function*() {
@@ -20,7 +23,7 @@ class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
         yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
         yield* Effect.succeed("this is a generator")
 
-        return Some.serviceMap({ a: 1 }) 
+        return Some.context({ a: 1 })
       })
     })
   }
@@ -28,7 +31,7 @@ class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
   static readonly Default = Layer.effect(this, this.make)
 }
 
-class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
+class MyContextProvider2 extends Context.Service<MyContextProvider2>()(
   "MyContextProvider2",
   {
     make: Effect.gen(function*() {
@@ -37,7 +40,7 @@ class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
       return Effect.gen(function*() {
         // we test without dependencies, so that we end up with an R of never.
 
-        return SomeElse.serviceMap({ b: 2 })
+        return SomeElse.context({ b: 2 })
       })
     })
   }
@@ -45,7 +48,7 @@ class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
   static readonly Default = Layer.effect(this, this.make)
 }
 
-class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
+class MyContextProvider2Gen extends Context.Service<MyContextProvider2Gen>()(
   "MyContextProvider2Gen",
   {
     make: Effect.gen(function*() {
@@ -54,7 +57,7 @@ class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
       return function*() {
         // we test without dependencies, so that we end up with an R of never
 
-        return SomeElse.serviceMap({ b: 2 })
+        return SomeElse.context({ b: 2 })
       }
     })
   }
@@ -63,7 +66,7 @@ class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProviderGen extends ServiceMap.Service<MyContextProviderGen>()(
+class MyContextProviderGen extends Context.Service<MyContextProviderGen>()(
   "MyContextProviderGen",
   {
     make: Effect.gen(function*() {
@@ -77,7 +80,7 @@ class MyContextProviderGen extends ServiceMap.Service<MyContextProviderGen>()(
         yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
         yield* Effect.succeed("this is a generator")
 
-        return Some.serviceMap({ a: 1 })
+        return Some.context({ a: 1 })
       }
     })
   }
@@ -100,7 +103,7 @@ export const someContextProvider = ContextProvider({
       // currently the effectful context provider cannot trigger an error when building the per request context
       // if (Math.random() > 0.5) return yield* new CustomError2()
 
-      return Some.serviceMap({ a: 1 })
+      return Some.context({ a: 1 })
     })
   })
 })
@@ -119,7 +122,7 @@ export const someContextProviderGen = ContextProvider({
       // currently the effectful context provider cannot trigger an error when building the per request context
       // if (Math.random() > 0.5) return yield* new CustomError2()
 
-      return Some.serviceMap({ a: 1 })
+      return Some.context({ a: 1 })
     }
   })
 })

package/test/controller.test.ts

@@ -1,16 +1,20 @@
 /* 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 { Effect, Layer, S, Scope, ServiceMap } from "effect-app"
 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 * as RpcX from "effect-app/rpc"
 import { MiddlewareMaker } from "effect-app/rpc"
+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, {
@@ -99,7 +103,7 @@ class MyContextProvider2
 
 //
 
-class Str extends ServiceMap.Service<Str, "str">()("str") {}
+class Str extends Context.Service<Str, "str">()("str") {}
 
 export class BogusMiddleware extends RpcX.RpcMiddleware.Tag<BogusMiddleware>()("BogusMiddleware") {
   static Default = Layer.make(this, {
@@ -188,13 +192,6 @@ const middlewareQuater = MiddlewareMaker
 
 expectTypeOf(middleware["Service"]).toEqualTypeOf<typeof middlewareQuater["Service"]>()
 
-const middleware2 = MiddlewareMaker
-  .Tag()("middleware", RequestContextMap)
-  .middleware(MyContextProvider)
-  .middleware(RequireRoles, Test)
-  .middleware(AllowAnonymous)
-  .middleware(...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2)
-
 export const middleware3 = MiddlewareMaker
   .Tag()("middleware", RequestContextMap)
   .middleware(...genericMiddlewares)
@@ -202,14 +199,17 @@ export const middleware3 = MiddlewareMaker
   .middleware(Test)
   .middleware(BogusMiddleware)
 
-export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)
+export const { TaggedRequestFor } = makeRpcClient(middleware)
+const Req = TaggedRequestFor("Something")
+const Command = Req.Command
+const Query = Req.Query
 
-export class Eff extends Req<Eff>()("Eff", {}, { success: S.Void }) {}
-export class Gen extends Req<Gen>()("Gen", {}) {}
+export class Eff extends Command<Eff>()("Eff", {}, { success: S.Void }) {}
+export class Gen extends Command<Gen>()("Gen", {}) {}
 
 expectTypeOf(Eff.error).toEqualTypeOf<typeof Gen.error>()
 
-export class DoSomething extends Req<DoSomething>()("DoSomething", {
+export class DoSomething extends Command<DoSomething>()("DoSomething", {
   id: S.String
 }, { success: S.Void }) {}
 
@@ -227,20 +227,20 @@ export class DoSomething extends Req<DoSomething>()("DoSomething", {
 //   )
 // )
 
-export class GetSomething extends Req<GetSomething>()("GetSomething", {
+export class GetSomething extends Query<GetSomething>()("GetSomething", {
   id: S.String
-}, { success: S.String }) {}
+}, { success: S.String, error: UnauthorizedError }) {}
 
-export class GetSomething2 extends Req<GetSomething2>()("GetSomething2", {
+export class GetSomething2 extends Query<GetSomething2>()("GetSomething2", {
   id: S.String
-}, { success: S.NumberFromString }) {}
+}, { success: S.FiniteFromString }) {}
 
-const Something = { Eff, Gen, DoSomething, GetSomething, GetSomething2, meta: { moduleName: "Something" as const } }
+const Something = { Eff, Gen, DoSomething, GetSomething, GetSomething2 }
 
 // const client = ApiClientFactory.makeFor(Layer.empty)(Something)
 // client.pipe(Effect.map(c => c.DoSomething.name))
 
-export class SomethingService extends ServiceMap.Service<SomethingService>()(
+export class SomethingService extends Context.Service<SomethingService>()(
   "SomethingService",
   {
     make: Effect.gen(function*() {
@@ -260,7 +260,7 @@ declare const a: {
   (opt: { b: 3 }): void
 }
 
-export class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
+export class SomethingRepo extends Context.Service<SomethingRepo>()(
   "SomethingRepo",
   {
     make: Effect.gen(function*() {
@@ -273,7 +273,7 @@ export class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
   static Default = Layer.effect(this, this.make).pipe(Layer.provide(SomethingService.Default))
 }
 
-export class SomethingService2 extends ServiceMap.Service<SomethingService2>()(
+export class SomethingService2 extends Context.Service<SomethingService2>()(
   "SomethingService2",
   {
     make: Effect.gen(function*() {
@@ -284,13 +284,9 @@ export class SomethingService2 extends ServiceMap.Service<SomethingService2>()(
   static Default = Layer.effect(this, this.make)
 }
 
-export const { Router, matchAll } = makeRouter(
-  middleware
-)
+export const { Router, matchAll } = makeRouter(middleware.Default)
 
-export const r2 = makeRouter(
-  Object.assign(middleware2, { Default: middleware2.layer.pipe(Layer.provide([...MiddlewaresLive])) })
-)
+export const r2 = makeRouter(middleware.Default)
 
 const router = Router(Something)({
   dependencies: [
@@ -348,7 +344,7 @@ const router = Router(Something)({
         }
       },
       GetSomething2: {
-        raw: Some.use(() => Effect.succeed("12"))
+        raw: () => Some.use(() => Effect.succeed("12"))
       }
     })
   }
@@ -413,7 +409,7 @@ const router2 = r2.Router(Something)({
         }
       },
       GetSomething2: {
-        raw: Some.use(() => Effect.succeed("12"))
+        raw: () => Some.use(() => Effect.succeed("12"))
       }
     })
   }

package/test/cosmos-query.test.ts

@@ -0,0 +1,159 @@
+/* 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 { buildWhereCosmosQuery3 } from "../src/Store/Cosmos/query.js"
+
+class Order extends S.Class<Order>("Order")({
+  id: S.String,
+  packages: S.Array(S.Struct({ id: S.String, weight: S.Finite }))
+}) {}
+
+type OrderEnc = S.Codec.Encoded<typeof Order>
+
+// Length projection via `relation(...).length()` should emit a scalar
+// ARRAY_LENGTH expression rather than pulling (or reshaping) the array.
+describe("cosmos query projection: array length", () => {
+  it("projects packages length via ARRAY_LENGTH", () => {
+    const q = make<OrderEnc>().pipe(
+      projectComputed(
+        S.Struct({ id: S.String, packageCount: S.NonNegativeInt }),
+        computed({ packageCount: relation<OrderEnc>("packages").length() })
+      )
+    )
+
+    const ir = toFilter(q as any, Order as any)
+
+    const result = buildWhereCosmosQuery3(
+      "id",
+      ir.filter ?? [],
+      "Orders",
+      {},
+      ir.select as any
+    )
+
+    expect(result.query).toMatch(/ARRAY_LENGTH\(f(?:\.packages|\["packages"\])\)/)
+    expect(result.query).toContain("AS packageCount")
+    // Must not pull the full array nor reshape via subquery
+    expect(result.query).not.toMatch(/ARRAY\s*\(\s*SELECT[^)]*FROM\s+t\s+in\s+f[\.\["]/i)
+    expect(result.query).not.toMatch(/SELECT VALUE COUNT/)
+  })
+})
+
+// Regression: `relation-every` previously walked its filter twice (once for the
+// shared `where` variable, once for the NOT-EXISTS branch), double-bumping the
+// shared `i` counter and shifting every subsequent @v index against the bound
+// params array. Verify each filter element binds exactly one parameter and that
+// @v indices in the emitted SQL line up with the bindings.
+describe("cosmos query projection: relation-every parameter binding", () => {
+  class Item extends S.Class<Item>("Item")({
+    state: S.Struct({ _tag: S.Literals(["initial", "picking", "picked", "packed"]) })
+  }) {}
+  class DN extends S.Class<DN>("DN")({
+    id: S.String,
+    state: S.Struct({
+      _tag: S.Literals(["initial", "valid", "packed", "closed"]),
+      at: S.String
+    }),
+    items: S.Array(Item)
+  }) {}
+  type DNEnc = S.Codec.Encoded<typeof DN>
+
+  it("binds @v indices contiguously across every + main filter", () => {
+    const q = make<DNEnc>().pipe(
+      where("state.at", "gte", "2026-05-01T00:00:00.000Z"),
+      and("state._tag", "neq", "closed"),
+      projectComputed(
+        S.Struct({
+          id: S.String,
+          allItemsPicked: S.Boolean,
+          allItemsPacked: S.Boolean
+        }),
+        computed({
+          allItemsPicked: relation<DNEnc>("items").every(where("state._tag", "picked")),
+          allItemsPacked: relation<DNEnc>("items").every(where("state._tag", "packed"))
+        })
+      )
+    )
+
+    const ir = toFilter(q as any, DN as any)
+    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "DN", {}, ir.select as any)
+
+    // Each filter element binds exactly one parameter: 2 every filters + 2 main filter = 4.
+    expect(result.parameters).toHaveLength(4)
+    expect(result.parameters.map((_) => _.value)).toEqual([
+      "picked",
+      "packed",
+      "2026-05-01T00:00:00.000Z",
+      "closed"
+    ])
+
+    // SQL must reference exactly @v0..@v3 in order, no gaps, no overruns.
+    const refs = [...result.query.matchAll(/@v\d+/g)].map((m) => m[0])
+    expect(refs).toEqual(["@v0", "@v1", "@v2", "@v3"])
+  })
+})
+
+describe("cosmos query: aggregate (GROUP BY + agg functions)", () => {
+  it("generates GROUP BY and SUM(IIF(...)) for agg-count-when", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [],
+      "Orders",
+      {},
+      [
+        { key: "city", path: "address.city" },
+        {
+          key: "activeCount",
+          aggregate: {
+            _tag: "agg-count-when",
+            filter: [{ t: "where", path: "status", op: "eq", value: "active" }]
+          }
+        },
+        { key: "total", aggregate: { _tag: "agg-count" } }
+      ] as any
+    )
+
+    expect(result.query).toContain("GROUP BY")
+    expect(result.query).toContain("SUM(IIF(")
+    expect(result.query).toContain("COUNT(1) AS total")
+    expect(result.query).toContain("AS city")
+    expect(result.parameters[0]!.value).toBe("active")
+  })
+
+  it("generates agg-sum / agg-min / agg-max expressions", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [],
+      "Orders",
+      {},
+      [
+        { key: "dept", path: "dept" },
+        { key: "totalSalary", aggregate: { _tag: "agg-sum", field: "salary" } },
+        { key: "minSalary", aggregate: { _tag: "agg-min", field: "salary" } },
+        { key: "maxSalary", aggregate: { _tag: "agg-max", field: "salary" } }
+      ] as any
+    )
+
+    expect(result.query).toContain(`SUM(f["salary"]) AS totalSalary`)
+    expect(result.query).toContain(`MIN(f["salary"]) AS minSalary`)
+    expect(result.query).toContain(`MAX(f["salary"]) AS maxSalary`)
+    expect(result.query).toMatch(/GROUP BY f(?:\.dept|\["dept"\])/)
+  })
+
+  it("generates correct GROUP BY for nested path field", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [],
+      "Orders",
+      {},
+      [
+        { key: "city", path: "address.city" },
+        { key: "count", aggregate: { _tag: "agg-count" } }
+      ] as any
+    )
+
+    // Must GROUP BY the nested path in Cosmos access notation
+    expect(result.query).toMatch(/GROUP BY f(?:\.address\.city|\["address"\]\["city"\])/)
+  })
+})

package/test/dist/_check-agg-infer.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NoZWNrLWFnZy1pbmZlci50ZXN0LWQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL19jaGVjay1hZ2ctaW5mZXIudGVzdC1kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/test/dist/_check-agg-infer.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_check-agg-infer.test-d.d.ts","sourceRoot":"","sources":["../_check-agg-infer.test-d.ts"],"names":[],"mappings":""}

package/test/dist/_check-agg-infer.test-d.js

@@ -0,0 +1,19 @@
+import * as S from "effect-app/Schema";
+import { aggregate, make, where } from "effect-app/Model/query";
+const baseSchema = S.Struct({
+    id: S.String,
+    address: S.Struct({ city: S.String }),
+    active: S.Boolean,
+    qty: S.Number
+});
+// Should compile — Row inferred from pipe
+const _ok = make().pipe(aggregate(S.Struct({ city: S.String, count: S.NonNegativeInt, total: S.Number }), ($) => ({
+    city: $.field("address.city"),
+    count: $.countWhen((q) => q.pipe(where("active", true))),
+    total: $.sum("qty")
+})));
+// Should ERROR — bad path
+const _bad = make().pipe(aggregate(S.Struct({ a: S.String }), ($) => ({
+    a: $.field("nonexistent")
+})));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NoZWNrLWFnZy1pbmZlci50ZXN0LWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9fY2hlY2stYWdnLWluZmVyLnRlc3QtZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssQ0FBQyxNQUFNLG1CQUFtQixDQUFBO0FBQ3RDLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxNQUFNLHdCQUF3QixDQUFBO0FBRS9ELE1BQU0sVUFBVSxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFDMUIsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNO0lBQ1osT0FBTyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQ3JDLE1BQU0sRUFBRSxDQUFDLENBQUMsT0FBTztJQUNqQixHQUFHLEVBQUUsQ0FBQyxDQUFDLE1BQU07Q0FDZCxDQUFDLENBQUE7QUFHRiwwQ0FBMEM7QUFDMUMsTUFBTSxHQUFHLEdBQUcsSUFBSSxFQUFPLENBQUMsSUFBSSxDQUMxQixTQUFTLENBQ1AsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsY0FBYyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsRUFDdEUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDTixJQUFJLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxjQUFjLENBQUM7SUFDN0IsS0FBSyxFQUFFLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ3hELEtBQUssRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQztDQUNwQixDQUFDLENBQ0gsQ0FDRixDQUFBO0FBRUQsMEJBQTBCO0FBQzFCLE1BQU0sSUFBSSxHQUFHLElBQUksRUFBTyxDQUFDLElBQUksQ0FDM0IsU0FBUyxDQUNQLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQ3pCLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ04sQ0FBQyxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDO0NBQzFCLENBQUMsQ0FDSCxDQUNGLENBQUEifQ==

package/test/dist/_check-proj-infer.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NoZWNrLXByb2otaW5mZXIudGVzdC1kLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9fY2hlY2stcHJvai1pbmZlci50ZXN0LWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/test/dist/_check-proj-infer.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_check-proj-infer.test-d.d.ts","sourceRoot":"","sources":["../_check-proj-infer.test-d.ts"],"names":[],"mappings":""}

package/test/dist/_check-proj-infer.test-d.js

@@ -0,0 +1,16 @@
+import * as S from "effect-app/Schema";
+import { make, projectComputed, where } from "effect-app/Model/query";
+const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ articleId: S.String, qty: S.Number, note: S.String }))
+});
+// Should compile — Row inferred from pipe
+const _ok = make().pipe(projectComputed(S.Struct({ id: S.String, total: S.Number, distinctArticles: S.NonNegativeInt }), ({ relation }) => ({
+    total: relation("items").sum("qty"),
+    distinctArticles: relation("items").distinctCount("articleId", where("qty", "gte", 0))
+})));
+// Should ERROR — bad path on relation element
+const _bad = make().pipe(projectComputed(S.Struct({ a: S.Number }), ({ relation }) => ({
+    a: relation("items").sum("nonexistent")
+})));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NoZWNrLXByb2otaW5mZXIudGVzdC1kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vX2NoZWNrLXByb2otaW5mZXIudGVzdC1kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sbUJBQW1CLENBQUE7QUFDdEMsT0FBTyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsS0FBSyxFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFFckUsTUFBTSxVQUFVLEdBQUcsQ0FBQyxDQUFDLE1BQU0sQ0FBQztJQUMxQixFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU07SUFDWixLQUFLLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0NBQ2pGLENBQUMsQ0FBQTtBQUdGLDBDQUEwQztBQUMxQyxNQUFNLEdBQUcsR0FBRyxJQUFJLEVBQU8sQ0FBQyxJQUFJLENBQzFCLGVBQWUsQ0FDYixDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDLGNBQWMsRUFBRSxDQUFDLEVBQy9FLENBQUMsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNqQixLQUFLLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUM7SUFDbkMsZ0JBQWdCLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLGFBQWEsQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7Q0FDdkYsQ0FBQyxDQUNILENBQ0YsQ0FBQTtBQUVELDhDQUE4QztBQUM5QyxNQUFNLElBQUksR0FBRyxJQUFJLEVBQU8sQ0FBQyxJQUFJLENBQzNCLGVBQWUsQ0FDYixDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUN6QixDQUFDLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDakIsQ0FBQyxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDO0NBQ3hDLENBQUMsQ0FDSCxDQUNGLENBQUEifQ==

package/test/dist/_check-tighten.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NoZWNrLXRpZ2h0ZW4udGVzdC1kLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9fY2hlY2stdGlnaHRlbi50ZXN0LWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/test/dist/_check-tighten.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_check-tighten.test-d.d.ts","sourceRoot":"","sources":["../_check-tighten.test-d.ts"],"names":[],"mappings":""}

package/test/dist/_check-tighten.test-d.js

@@ -0,0 +1,21 @@
+import * as S from "effect-app/Schema";
+import { computed, relation } from "effect-app/Model/query";
+const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ articleId: S.String, qty: S.Number }))
+});
+// Should compile:
+const _ok = computed({
+    a: relation("items").sum("qty"),
+    b: relation("items").distinctCount("articleId"),
+    c: relation("items").collect("articleId"),
+    d: relation("items").collectFields(["articleId", "qty"])
+});
+// Should ERROR — invalid field paths
+const _bad = computed({
+    a: relation("items").sum("nonexistent"),
+    b: relation("items").distinctCount("not_a_field"),
+    c: relation("items").collect("zzz"),
+    d: relation("items").collectFields(["zzz"])
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NoZWNrLXRpZ2h0ZW4udGVzdC1kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vX2NoZWNrLXRpZ2h0ZW4udGVzdC1kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sbUJBQW1CLENBQUE7QUFDdEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUUzRCxNQUFNLFVBQVUsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzFCLEVBQUUsRUFBRSxDQUFDLENBQUMsTUFBTTtJQUNaLEtBQUssRUFBRSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7Q0FDakUsQ0FBQyxDQUFBO0FBR0Ysa0JBQWtCO0FBQ2xCLE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQztJQUNuQixDQUFDLEVBQUUsUUFBUSxDQUFNLE9BQU8sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUM7SUFDcEMsQ0FBQyxFQUFFLFFBQVEsQ0FBTSxPQUFPLENBQUMsQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDO0lBQ3BELENBQUMsRUFBRSxRQUFRLENBQU0sT0FBTyxDQUFDLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQztJQUM5QyxDQUFDLEVBQUUsUUFBUSxDQUFNLE9BQU8sQ0FBQyxDQUFDLGFBQWEsQ0FBQyxDQUFDLFdBQVcsRUFBRSxLQUFLLENBQUMsQ0FBQztDQUM5RCxDQUFDLENBQUE7QUFFRixxQ0FBcUM7QUFDckMsTUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDO0lBQ3BCLENBQUMsRUFBRSxRQUFRLENBQU0sT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQztJQUM1QyxDQUFDLEVBQUUsUUFBUSxDQUFNLE9BQU8sQ0FBQyxDQUFDLGFBQWEsQ0FBQyxhQUFhLENBQUM7SUFDdEQsQ0FBQyxFQUFFLFFBQVEsQ0FBTSxPQUFPLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO0lBQ3hDLENBQUMsRUFBRSxRQUFRLENBQU0sT0FBTyxDQUFDLENBQUMsYUFBYSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUM7Q0FDakQsQ0FBQyxDQUFBIn0=