@effect-app/infra 2.69.0 → 2.70.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @effect-app/infra
 
+## 2.70.0
+
+### Minor Changes
+
+- d29cb1b: refactor: drop optional identifier for Schema classes.
+
+### Patch Changes
+
+- 4ae597d: update packages
+- Updated dependencies [d29cb1b]
+  - effect-app@2.47.0
+
+## 2.69.1
+
+### Patch Changes
+
+- b095bb5: tscp
+- Updated dependencies [b095bb5]
+  - effect-app@2.46.1
+
 ## 2.69.0
 
 ### Minor Changes

package/dist/Emailer/Sendgrid.d.ts

@@ -10,9 +10,6 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     to: EmailData | EmailData[];
     cc: EmailData | EmailData[];
     bcc: EmailData | EmailData[];
-    headers?: {
-        [key: string]: string;
-    };
     replyTo?: EmailData;
     sendAt?: number;
     subject?: string;
@@ -26,6 +23,9 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     sections?: {
         [key: string]: string;
     };
+    headers?: {
+        [key: string]: string;
+    };
     categories?: string[];
     category?: string;
     customArgs?: {
@@ -49,9 +49,6 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     to: EmailData | EmailData[];
     cc: EmailData | EmailData[];
     bcc: EmailData | EmailData[];
-    headers?: {
-        [key: string]: string;
-    };
     replyTo?: EmailData;
     sendAt?: number;
     subject?: string;
@@ -65,6 +62,9 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     sections?: {
         [key: string]: string;
     };
+    headers?: {
+        [key: string]: string;
+    };
     categories?: string[];
     category?: string;
     customArgs?: {
@@ -88,9 +88,6 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     to: EmailData | EmailData[];
     cc: EmailData | EmailData[];
     bcc: EmailData | EmailData[];
-    headers?: {
-        [key: string]: string;
-    };
     replyTo?: EmailData;
     sendAt?: number;
     subject?: string;
@@ -104,6 +101,9 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     sections?: {
         [key: string]: string;
     };
+    headers?: {
+        [key: string]: string;
+    };
     categories?: string[];
     category?: string;
     customArgs?: {
@@ -127,9 +127,6 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     to: EmailData | EmailData[];
     cc: EmailData | EmailData[];
     bcc: EmailData | EmailData[];
-    headers?: {
-        [key: string]: string;
-    };
     replyTo?: EmailData;
     sendAt?: number;
     subject?: string;
@@ -143,6 +140,9 @@ export declare function renderMessage(forceFake: boolean): (msg: EmailMsg) => {
     sections?: {
         [key: string]: string;
     };
+    headers?: {
+        [key: string]: string;
+    };
     categories?: string[];
     category?: string;
     customArgs?: {

package/dist/Emailer/service.d.ts

@@ -24,7 +24,7 @@ declare const Emailer_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         sendMail: (msg: EmailMsgOptionalFrom) => Effect<void, SendMailError>;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_1, infer R_3> ? Effect.Effect<A_1, E_1, R_3 | Emailer> : Effect.Effect<X, never, Emailer>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_1, infer R_3> ? Effect.Effect<A_1, E_1, Emailer | R_3> : Effect.Effect<X, never, Emailer>;
 };
 export declare class Emailer extends Emailer_base {
 }

package/dist/MainFiberSet.d.ts

@@ -44,7 +44,7 @@ declare const MainFiberSet_base: (abstract new (service: {
         run: <R_1, XE extends never, XA extends unknown>(effect: Effect.Effect<XA, XE, R_1>) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R_1>;
         add: (...fibers: Fiber.RuntimeFiber<never, never>[]) => Effect.Effect<void, never, never>;
         addAll: (fibers: readonly Fiber.RuntimeFiber<never, never>[]) => Effect.Effect<void, never, never>;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, MainFiberSet | R_4> : Effect.Effect<X, never, MainFiberSet>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | MainFiberSet> : Effect.Effect<X, never, MainFiberSet>;
 };
 /**
  * Whenever you fork long running (e.g worker) fibers via e.g `Effect.forkScoped` or `Effect.forkDaemon`

package/dist/Model/Repository/internal/internal.d.ts

@@ -20,12 +20,12 @@ export declare function makeRepoInternal<Evt = never>(): <ItemType extends strin
         config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (a: Encoded) => string;
         };
-    }) => Effect.Effect<Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish>, E, R | RInitial | StoreMaker>;
+    }) => Effect.Effect<Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish>, E, StoreMaker | R | RInitial>;
     Q: Q.Query<Encoded>;
 };
 export declare function makeStore<Encoded extends FieldValues>(): <ItemType extends string, R, E, T, IdKey extends keyof Encoded>(name: ItemType, schema: S.Schema<T, E, R>, mapTo: (e: E, etag: string | undefined) => Encoded, idKey: IdKey) => <RInitial = never, EInitial = never>(makeInitial?: Effect<readonly T[], EInitial, RInitial> | undefined, config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
     partitionValue?: (a: Encoded) => string;
-}) => Effect.Effect<import("../../../Store.js").Store<IdKey, Encoded, PersistenceModelType<Encoded>>, EInitial, R | RInitial | StoreMaker>;
+}) => Effect.Effect<import("../../../Store.js").Store<IdKey, Encoded, PersistenceModelType<Encoded>>, EInitial, StoreMaker | R | RInitial>;
 export interface Repos<T, Encoded extends {
     id: string;
 }, RSchema, Evt, ItemType extends string, IdKey extends keyof T, RPublish> {

package/dist/Model/query/new-kid-interpreter.d.ts

@@ -21,7 +21,7 @@ export declare const toFilter: <TFieldValues extends FieldValues, A, R, TFieldVa
         key: import("../filter/types/path/eager.js").Path<TFieldValues>;
         direction: "ASC" | "DESC";
     }[]];
-    ttype: "one" | "count" | "many";
+    ttype: "one" | "many" | "count";
     mode: "project" | "collect" | "transform";
     filter: FilterResult[];
 };

package/dist/Operations.d.ts

@@ -54,15 +54,15 @@ declare const Operations_base: (abstract new (service: {
     update: (id: OperationId, progress: OperationProgress) => Effect.Effect<void, never, never>;
 }>) & {
     toLayer: {
-        (): Layer.Layer<Operations, never, OperationsRepo | RequestFiberSet>;
+        (): Layer.Layer<Operations, never, RequestFiberSet | OperationsRepo>;
         <E_1, R_1>(eff: Effect.Effect<Omit<Operations, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<Operations, E_1, R_1>;
     };
     toLayerScoped: {
-        (): Layer.Layer<Operations, never, OperationsRepo | RequestFiberSet>;
+        (): Layer.Layer<Operations, never, RequestFiberSet | OperationsRepo>;
         <E_1, R_2>(eff: Effect.Effect<Context.TagClassShape<any, any>, E_1, R_2>): Layer.Layer<Operations, E_1, Exclude<R_2, Scope.Scope>>;
     };
     of: (service: Context.TagClassShape<any, any>) => Operations;
-    make: Effect.Effect<Operations, never, OperationsRepo | RequestFiberSet>;
+    make: Effect.Effect<Operations, never, RequestFiberSet | OperationsRepo>;
 } & Context.Tag<Operations, Operations> & {
     cleanup: Effect.Effect<void[], never, Operations>;
     register: (title: S.NonEmptyString2k) => Effect.Effect<S.StringId, never, Scope.Scope | Operations>;

package/dist/QueueMaker/SQLQueue.d.ts

@@ -13,6 +13,6 @@ export declare function makeSQLQueue<Evt extends {
     _tag: string;
 }, EvtE, DrainEvtE>(queueName: NonEmptyString255, queueDrainName: NonEmptyString255, schema: S.Schema<Evt, EvtE>, drainSchema: S.Schema<DrainEvt, DrainEvtE>): Effect.Effect<{
     publish: (messages_0: Evt, ...messages: Evt[]) => Effect.Effect<void, never, never>;
-    drain: <DrainE, DrainR>(handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>, sessionId?: string) => Effect.Effect<never, never, Exclude<Exclude<Exclude<DrainR, Tracer.ParentSpan>, import("../RequestContext.js").LocaleRef | import("../Store/Memory.js").storeId | import("../Store/ContextMapContainer.js").ContextMapContainer>, Tracer.ParentSpan>>;
+    drain: <DrainE, DrainR>(handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>, sessionId?: string) => Effect.Effect<never, never, Exclude<Exclude<Exclude<DrainR, Tracer.ParentSpan>, import("../RequestContext.js").LocaleRef | import("../Store/ContextMapContainer.js").ContextMapContainer | import("../Store/Memory.js").storeId>, Tracer.ParentSpan>>;
 }, never, SqlClient.SqlClient>;
 //# sourceMappingURL=SQLQueue.d.ts.map

package/dist/QueueMaker/memQueue.d.ts

@@ -9,6 +9,6 @@ export declare function makeMemQueue<Evt extends {
     _tag: string;
 }, EvtE, DrainEvtE>(queueName: string, queueDrainName: string, schema: S.Schema<Evt, EvtE>, drainSchema: S.Schema<DrainEvt, DrainEvtE>): Effect.Effect<{
     publish: (messages_0: Evt, ...messages: Evt[]) => Effect.Effect<void, never, never>;
-    drain: <DrainE, DrainR>(handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>, sessionId?: string) => Effect.Effect<never, never, Exclude<Exclude<Exclude<DrainR, Tracer.ParentSpan>, import("../RequestContext.js").LocaleRef | import("../Store/Memory.js").storeId | import("../Store/ContextMapContainer.js").ContextMapContainer>, Tracer.ParentSpan>>;
+    drain: <DrainE, DrainR>(handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>, sessionId?: string) => Effect.Effect<never, never, Exclude<Exclude<Exclude<DrainR, Tracer.ParentSpan>, import("../RequestContext.js").LocaleRef | import("../Store/ContextMapContainer.js").ContextMapContainer | import("../Store/Memory.js").storeId>, Tracer.ParentSpan>>;
 }, never, MemQueue>;
 //# sourceMappingURL=memQueue.d.ts.map

package/dist/QueueMaker/sbqueue.d.ts

@@ -9,8 +9,8 @@ export declare function makeServiceBusQueue<Evt extends {
     id: StringId;
     _tag: string;
 }, EvtE, DrainEvtE>(queueName: string, queueDrainName: string, schema: S.Schema<Evt, EvtE>, drainSchema: S.Schema<DrainEvt, DrainEvtE>): Effect.Effect<{
-    drain: <DrainE, DrainR>(handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>, sessionId?: string) => Effect.Effect<never, never, import("effect/Scope").Scope | Exclude<Exclude<Exclude<DrainR, Tracer.ParentSpan>, import("../RequestContext.js").LocaleRef | import("../Store/Memory.js").storeId | import("../Store/ContextMapContainer.js").ContextMapContainer>, ServiceBusReceiverFactory>>;
+    drain: <DrainE, DrainR>(handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>, sessionId?: string) => Effect.Effect<never, never, import("effect/Scope").Scope | Exclude<Exclude<Exclude<DrainR, Tracer.ParentSpan>, import("../RequestContext.js").LocaleRef | import("../Store/ContextMapContainer.js").ContextMapContainer | import("../Store/Memory.js").storeId>, ServiceBusReceiverFactory>>;
     publish: (messages_0: Evt, ...messages: Evt[]) => Effect.Effect<void, never, never>;
-}, never, ServiceBusReceiverFactory | import("@azure/service-bus").ServiceBusSender>;
-export declare function makeServiceBusLayers(url: string, queueName: string, queueDrainName: string): Layer.Layer<ServiceBusReceiverFactory | import("@azure/service-bus").ServiceBusSender, never, never>;
+}, never, import("@azure/service-bus").ServiceBusSender | ServiceBusReceiverFactory>;
+export declare function makeServiceBusLayers(url: string, queueName: string, queueDrainName: string): Layer.Layer<import("@azure/service-bus").ServiceBusSender | ServiceBusReceiverFactory, never, never>;
 //# sourceMappingURL=sbqueue.d.ts.map

package/dist/RequestContext.d.ts

@@ -27,9 +27,9 @@ declare const RequestContext_base: S.EnhancedClass<RequestContext, {
         } & S.WithDefaults<S.Schema<string & S.StringIdBrand & import("effect-app/ids").UserProfileIdBrand, string, never>>;
     }>>;
 }, RequestContext.Encoded, never, {
+    readonly name: string & S.NonEmptyString255Brand;
     readonly locale: "en" | "de";
     readonly namespace: string & S.NonEmptyString255Brand;
-    readonly name: string & S.NonEmptyString255Brand;
     readonly span: {
         readonly traceId: string;
         readonly spanId: string;

package/dist/Store/ContextMapContainer.d.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect-app";
 import { ContextMap } from "./service.js";
-declare const ContextMapContainer_base: Context.ReferenceClass<ContextMapContainer, "ContextMapContainer", ContextMap | "root">;
+declare const ContextMapContainer_base: Context.ReferenceClass<ContextMapContainer, "ContextMapContainer", "root" | ContextMap>;
 export declare class ContextMapContainer extends ContextMapContainer_base {
     static readonly layer: Layer.Layer<ContextMapContainer, never, never>;
 }

package/dist/Store/service.d.ts

@@ -92,7 +92,7 @@ declare const StoreMaker_base: (abstract new (service: {
 } & Context.Tag<StoreMaker, StoreMaker> & {} & {
     use: <X>(body: (_: {
         make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(name: string, idKey: IdKey, seed?: Effect<Iterable<Encoded>, E, R>, config?: StoreConfig<Encoded>) => Effect<Store<IdKey, Encoded>, E, R>;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_1, infer R_3> ? Effect.Effect<A_1, E_1, StoreMaker | R_3> : Effect.Effect<X, never, StoreMaker>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_1, infer R_3> ? Effect.Effect<A_1, E_1, R_3 | StoreMaker> : Effect.Effect<X, never, StoreMaker>;
 };
 export declare class StoreMaker extends StoreMaker_base {
 }
@@ -127,7 +127,7 @@ declare const ContextMap_base: (abstract new (service: {
     use: <X>(body: (_: {
         get: (id: string) => string | undefined;
         set: (id: string, eTag: string | undefined) => void;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | ContextMap> : Effect.Effect<X, never, ContextMap>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, ContextMap | R_4> : Effect.Effect<X, never, ContextMap>;
 };
 export declare class ContextMap extends ContextMap_base {
 }

package/dist/adapters/ServiceBus.d.ts

@@ -29,7 +29,7 @@ export declare class ServiceBusReceiverFactory extends ServiceBusReceiverFactory
     static readonly Live: (queueName: string) => Layer.Layer<ServiceBusReceiverFactory, never, ServiceBusClient>;
 }
 export declare function sendMessages(messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch, options?: OperationOptionsBase): Effect.Effect<void, never, ServiceBusSender>;
-export declare function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string): Effect.Effect<void, never, Scope.Scope | RMsg | RErr | ServiceBusReceiverFactory>;
+export declare function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string): Effect.Effect<void, never, Scope.Scope | ServiceBusReceiverFactory | RMsg | RErr>;
 export interface MessageHandlers<RMsg, RErr> {
     /**
      * Handler that processes messages from service bus.

package/dist/api/internal/RequestContextMiddleware.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect-app";
 import { HttpServerRequest, HttpServerResponse } from "effect-app/http";
 import { Locale } from "../../RequestContext.js";
-export declare const RequestContextMiddleware: (defaultLocale?: Locale) => <E, R>(app: import("@effect/platform/HttpApp").Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | Exclude<Exclude<R, import("effect/Tracer").ParentSpan>, import("../../RequestContext.js").LocaleRef | import("../../Store/Memory.js").storeId | import("../../Store/ContextMapContainer.js").ContextMapContainer>>;
+export declare const RequestContextMiddleware: (defaultLocale?: Locale) => <E, R>(app: import("@effect/platform/HttpApp").Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | Exclude<Exclude<R, import("effect/Tracer").ParentSpan>, import("../../RequestContext.js").LocaleRef | import("../../Store/ContextMapContainer.js").ContextMapContainer | import("../../Store/Memory.js").storeId>>;
 //# sourceMappingURL=RequestContextMiddleware.d.ts.map

package/dist/api/setupRequest.d.ts

@@ -9,6 +9,6 @@ export declare const getRC: Effect.Effect<{
     namespace: NonEmptyString255;
 }, never, never>;
 export declare const setupRequestContextFromCurrent: (name?: string, options?: Tracer.SpanOptions) => <R, E, A>(self: Effect<A, E, R>) => Effect.Effect<A, E, Exclude<Exclude<R, Tracer.ParentSpan>, ContextMapContainer>>;
-export declare function setupRequestContext<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext): Effect.Effect<A, E, Exclude<Exclude<R, Tracer.ParentSpan>, LocaleRef | storeId | ContextMapContainer>>;
-export declare function setupRequestContextWithCustomSpan<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext, name: string, options?: Tracer.SpanOptions): Effect.Effect<A, E, Exclude<Exclude<R, Tracer.ParentSpan>, LocaleRef | storeId | ContextMapContainer>>;
+export declare function setupRequestContext<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext): Effect.Effect<A, E, Exclude<Exclude<R, Tracer.ParentSpan>, LocaleRef | ContextMapContainer | storeId>>;
+export declare function setupRequestContextWithCustomSpan<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext, name: string, options?: Tracer.SpanOptions): Effect.Effect<A, E, Exclude<Exclude<R, Tracer.ParentSpan>, LocaleRef | ContextMapContainer | storeId>>;
 //# sourceMappingURL=setupRequest.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "2.69.0",
+  "version": "2.70.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -13,7 +13,7 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "7.0.1",
     "query-string": "^9.2.2",
-    "effect-app": "2.46.0"
+    "effect-app": "2.47.0"
   },
   "devDependencies": {
     "@azure/cosmos": "^4.5.0",
@@ -363,15 +363,15 @@
   "sideEffects": false,
   "scripts": {
     "watch": "pnpm build:tsc -w",
-    "build:tsc": "pnpm clean-dist && effect-app-cli packagejson tsc --build",
+    "build:tsc": "pnpm clean-dist && effect-app-cli packagejson tspc --build",
     "build": "pnpm build:tsc",
-    "watch2": "pnpm clean-dist && NODE_OPTIONS=--max-old-space-size=6144 tsc -w",
+    "watch2": "pnpm clean-dist && NODE_OPTIONS=--max-old-space-size=6144 tspc -w",
     "clean": "rm -rf dist",
     "clean-dist": "sh ../../scripts/clean-dist.sh",
     "circular": "pnpm circular:src && pnpm circular:dist",
     "circular:src": "madge --circular --ts-config ./tsconfig.json --extensions ts ./src",
     "circular:dist": "madge --circular --extensions js ./dist",
-    "compile": "NODE_OPTIONS=--max-old-space-size=6144 tsc --noEmit",
+    "compile": "NODE_OPTIONS=--max-old-space-size=6144 tspc --noEmit",
     "lint": "NODE_OPTIONS=--max-old-space-size=6144 ESLINT_TS=1 eslint ./src",
     "lint:watch": "ESLINT_TS=1 esw -w --changed --clear --ext ts,tsx .",
     "autofix": "pnpm lint --fix",
@@ -381,6 +381,6 @@
     "client": "node --experimental-specifier-resolution=node -r source-map-support/register ./dist/client.bin.js",
     "ncu": "ncu",
     "pub": "pnpm prepublish && npm publish --access public",
-    "prepublish": "pnpm build && cp -f ./tsconfig.json ./tsconfig.json.bak && node ../../scripts/mergeTsConfig.cjs ./tsconfig.json"
+    "prepublish": "pnpm build && cp -f ./tsconfig.json ./tsconfig.json.bak && node ../../scripts/mergeTsConfig.mjs ./tsconfig.json"
   }
 }

package/test/controller.test.ts

@@ -11,7 +11,7 @@ import type * as EffectRequest from "effect/Request"
 import { SomeService } from "./query.test.js"
 
 class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
-  Class<UserProfile>()({
+  Class<UserProfile>("UserProfile")({
     id: S.String
   })
 ) {
@@ -31,8 +31,7 @@ export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<So
 export class ContextMaker extends Effect.Service<ContextMaker>()("ContextMaker", {
   effect: Effect.gen(function*() {
     yield* SomeService
-    const SomeContext = Layer.sync(Some, () => new Some({ a: 1 }))
-    return Layer.build(SomeContext)
+    return Effect.sync(() => Context.make(Some, new Some({ a: 1 })))
   })
 }) {}
 

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

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA8B,MAAM,+BAA+B,CAAA;AAC7G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAoC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClI,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;;;;;;;;AAE7C,cAAM,WAAY,SAAQ,gBAIzB;CACA;;;;;;AAED,cAAM,gBAAiB,SAAQ,qBAE7B;CAAG;AAEL,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;AAGxF,qBAAa,YAAa,SAAQ,iBAMhC;CAAG;AAEL,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAE3F,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AA0GD,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAE1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFAAiC,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA8B,MAAM,+BAA+B,CAAA;AAC7G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAoC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClI,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;;;;;;;;AAE7C,cAAM,WAAY,SAAQ,gBAIzB;CACA;;;;;;AAED,cAAM,gBAAiB,SAAQ,qBAE7B;CAAG;AAEL,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;AAGxF,qBAAa,YAAa,SAAQ,iBAKhC;CAAG;AAEL,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAE3F,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AA0GD,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAE1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFAAiC,CAAA"}

package/test/query.test.ts

@@ -13,7 +13,7 @@ const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
 const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
 const someUnion = S.Union(str, num)
 
-export class Something extends S.Class<Something>()({
+export class Something extends S.Class<Something>("Something")({
   id: S.StringId.withDefault,
   displayName: S.NonEmptyString255,
   name: S.NullOr(S.NonEmptyString255).withDefault,
@@ -467,22 +467,22 @@ it(
   () =>
     Effect
       .gen(function*() {
-        class AA extends S.Class<AA>()({
+        class AA extends S.Class<AA>("AA")({
           id: S.Literal("AA"),
           a: S.Unknown
         }) {}
 
-        class BB extends S.Class<BB>()({
+        class BB extends S.Class<BB>("BB")({
           id: S.Literal("BB"),
           b: S.Unknown
         }) {}
 
-        class CC extends S.Class<CC>()({
+        class CC extends S.Class<CC>("CC")({
           id: S.Literal("CC"),
           c: S.Unknown
         }) {}
 
-        class DD extends S.Class<DD>()({
+        class DD extends S.Class<DD>("DD")({
           id: S.Literal("DD"),
           d: S.Unknown
         }) {}
@@ -661,12 +661,12 @@ it(
 it("remove null from one constituent of a tagged union", () =>
   Effect
     .gen(function*() {
-      class AA extends S.Class<AA>()({
+      class AA extends S.Class<AA>("AA")({
         id: S.Literal("AA"),
         a: S.String
       }) {}
 
-      class BB extends S.Class<BB>()({
+      class BB extends S.Class<BB>("BB")({
         id: S.Literal("BB"),
         b: S.NullOr(S.Number)
       }) {}
@@ -709,22 +709,22 @@ it("remove null from one constituent of a tagged union", () =>
 it("refine 3", () =>
   Effect
     .gen(function*() {
-      class AA extends S.Class<AA>()({
+      class AA extends S.Class<AA>("AA")({
         id: S.Literal("AA"),
         a: S.Unknown
       }) {}
 
-      class BB extends S.Class<BB>()({
+      class BB extends S.Class<BB>("BB")({
         id: S.Literal("BB"),
         b: S.Unknown
       }) {}
 
-      class CC extends S.Class<CC>()({
+      class CC extends S.Class<CC>("CC")({
         id: S.Literal("CC"),
         c: S.Unknown
       }) {}
 
-      class DD extends S.Class<DD>()({
+      class DD extends S.Class<DD>("DD")({
         id: S.Literal("DD"),
         d: S.Unknown
       }) {}
@@ -747,7 +747,7 @@ it("refine 3", () =>
 it("my test", () =>
   Effect
     .gen(function*() {
-      class AA extends S.Class<AA>()({
+      class AA extends S.Class<AA>("AA")({
         id: S.String,
         as: S.Array(S.String)
       }) {}
@@ -773,7 +773,7 @@ it("refine inner without imposing a projection", () =>
         b: S.Unknown
       }) {}
 
-      class Data extends S.Class<Data>()({
+      class Data extends S.Class<Data>("Data")({
         id: S.String,
         union: S.Union(AA, BB)
       }) {}
@@ -940,7 +940,7 @@ it("distribution over union", () =>
 it("refine nested union", () =>
   Effect
     .gen(function*() {
-      class TestNested extends S.Class<TestNested>()({ id: S.String, nested: TestUnion }) {}
+      class TestNested extends S.Class<TestNested>("TestNested")({ id: S.String, nested: TestUnion }) {}
 
       const repo = yield* makeRepo("test", TestNested, {})
 

package/test/rawQuery.test.ts

@@ -19,7 +19,7 @@ export const rt = ManagedRuntime.make(Layer.mergeAll(
   Logger.minimumLogLevel(LogLevel.Debug)
 ))
 
-class Something extends S.Class<Something>()({
+class Something extends S.Class<Something>("Something")({
   id: S.String,
   name: S.String,
   description: S.String,

package/tsconfig.json

@@ -15,6 +15,32 @@
     "checkJs": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
+    "plugins": [
+      {
+        "name": "ts-plugin-sort-import-suggestions",
+        "moveUpPatterns": [
+          "\\.{1,2}/",
+          "^(?:\\.\\./)+",
+          "^#",
+          "^@/",
+          "effect",
+          "^@effect/"
+        ],
+        "moveDownPatterns": [
+          "^node_modules/"
+        ],
+        "overrides": {
+          "effect-app": []
+        }
+      },
+      {
+        "name": "@effect/language-service",
+        "transform": "@effect/language-service/transform",
+        "diagnosticSeverity": {
+          "missingEffectServiceDependency": "error"
+        }
+      }
+    ],
     "module": "Node16",
     "lib": [
       "ES2023"