effect-app 3.0.0 → 3.0.1

package/dist/rpc/middleware-api.js

@@ -0,0 +1,88 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Rpc } from "@effect/rpc";
+import { Tag } from "@effect/rpc/RpcMiddleware";
+import { Context, Layer, S } from "effect-app";
+import { typedValuesOf } from "effect-app/utils";
+import { middlewareMaker } from "./generic-middleware.js";
+/** Adapter used when setting the dynamic prop on a middleware implementation */
+export const contextMap = (rcm, key) => ({
+    key,
+    settings: { service: rcm[key]["service"] }
+});
+const tag = Context.GenericTag("RequestContextConfig");
+/** Retrieves RequestContextConfig out of the RPC annotations */
+export const getConfig = () => (rpc) => {
+    return Context.getOrElse(rpc.annotations, tag, () => ({}));
+};
+const makeMiddlewareBasic = 
+// by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
+(rcm, ...make) => {
+    // reverse middlewares and wrap one after the other
+    const middleware = middlewareMaker(make);
+    const failures = make.map((_) => _.failure).filter(Boolean);
+    const provides = make.flatMap((_) => !_.provides ? [] : Array.isArray(_.provides) ? _.provides : [_.provides]);
+    const requires = make
+        .flatMap((_) => !_.requires ? [] : Array.isArray(_.requires) ? _.requires : [_.requires])
+        .filter((_) => !provides.includes(_));
+    const MiddlewareMaker = Tag()("MiddlewareMaker", {
+        failure: (failures.length > 0
+            ? S.Union(...failures)
+            : S.Never),
+        requires: (requires.length > 0
+            ? requires
+            : undefined),
+        provides: (provides.length > 0
+            ? provides
+            : undefined),
+        wrap: true
+    });
+    const layer = Layer
+        .scoped(MiddlewareMaker, middleware);
+    // add to the tag a default implementation
+    return Object.assign(MiddlewareMaker, {
+        layer,
+        // tag to be used to retrieve the RequestContextConfig from RPC annotations
+        requestContext: Context.GenericTag("RequestContextConfig"),
+        requestContextMap: rcm
+    });
+};
+export const makeMiddleware = (rcm) => {
+    let allMiddleware = [];
+    const requestContext = Context.GenericTag("RequestContextConfig");
+    const it = {
+        // rpc with config
+        rpc: (tag, options) => {
+            const config = options?.config ?? {};
+            // based on the config, we must enhance (union) or set failures.
+            // TODO: we should only include errors that are relevant based on the middleware config.ks
+            const error = options?.error;
+            const errors = typedValuesOf(rcm).map((_) => _.error).filter((_) => _ && _ !== S.Never); // TODO: only the errors relevant based on config
+            const newError = error ? S.Union(error, ...errors) : S.Union(...errors);
+            const rpc = Rpc.make(tag, { ...options, error: newError });
+            return Object.assign(rpc.annotate(requestContext, config), { config });
+        },
+        middleware: (...middlewares) => {
+            for (const mw of middlewares) {
+                // recall that we run middlewares in reverse order
+                allMiddleware = [mw, ...allMiddleware];
+            }
+            return allMiddleware.filter((m) => !!m.dynamic).length !== Object.keys(rcm).length
+                // for sure, until all the dynamic middlewares are provided it's non sensical to call makeMiddlewareBasic
+                ? it
+                // actually, we don't know yet if MiddlewareR is never, but we can't easily check it at runtime
+                : Object.assign(makeMiddlewareBasic(rcm, ...allMiddleware), it);
+        }
+    };
+    return it;
+};
+// alternatively consider group.serverMiddleware? hmmm
+export const middlewareGroup = (middleware) => (group) => {
+    const middlewaredGroup = group.middleware(middleware);
+    const toLayerOriginal = middlewaredGroup.toLayer.bind(middlewaredGroup);
+    return Object.assign(middlewaredGroup, {
+        toLayerDynamic: (build) => {
+            return toLayerOriginal(build); // ??
+        }
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/rpc/middleware-native.d.ts

@@ -0,0 +1,23 @@
+import { RpcMiddleware } from "@effect/rpc";
+import { Context } from "effect-app";
+declare const DevMode_base: Context.ReferenceClass<DevMode, "DevMode", boolean>;
+export declare class DevMode extends DevMode_base {
+}
+declare const RequestCacheMiddleware_base: RpcMiddleware.TagClass<RequestCacheMiddleware, "RequestCacheMiddleware", {
+    readonly wrap: true;
+}>;
+export declare class RequestCacheMiddleware extends RequestCacheMiddleware_base {
+}
+declare const ConfigureInterruptibilityMiddleware_base: RpcMiddleware.TagClass<ConfigureInterruptibilityMiddleware, "ConfigureInterruptibilityMiddleware", {
+    readonly wrap: true;
+}>;
+export declare class ConfigureInterruptibilityMiddleware extends ConfigureInterruptibilityMiddleware_base {
+}
+declare const LoggerMiddleware_base: RpcMiddleware.TagClass<LoggerMiddleware, "LoggerMiddleware", {
+    readonly wrap: true;
+}>;
+export declare class LoggerMiddleware extends LoggerMiddleware_base {
+}
+export declare const DefaultGenericMiddlewares: readonly [typeof RequestCacheMiddleware, typeof ConfigureInterruptibilityMiddleware, typeof LoggerMiddleware];
+export {};
+//# sourceMappingURL=middleware-native.d.ts.map

package/dist/rpc/middleware-native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-native.d.ts","sourceRoot":"","sources":["../../src/rpc/middleware-native.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;;AAEpC,qBAAa,OAAQ,SAAQ,YAAsE;CAAG;;;;AAEtG,qBAAa,sBACX,SAAQ,2BAAqF;CAC7F;;;;AAEF,qBAAa,mCACX,SAAQ,wCAEN;CACF;;;;AAEF,qBAAa,gBAAiB,SAAQ,qBAAyE;CAAG;AAElH,eAAO,MAAM,yBAAyB,+GAI5B,CAAA"}

package/dist/rpc/middleware-native.js

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { RpcMiddleware } from "@effect/rpc";
+import { Context } from "effect-app";
+export class DevMode extends Context.Reference()("DevMode", { defaultValue: () => false }) {
+}
+export class RequestCacheMiddleware extends RpcMiddleware.Tag()("RequestCacheMiddleware", { wrap: true }) {
+}
+export class ConfigureInterruptibilityMiddleware extends RpcMiddleware.Tag()("ConfigureInterruptibilityMiddleware", {
+    wrap: true
+}) {
+}
+export class LoggerMiddleware extends RpcMiddleware.Tag()("LoggerMiddleware", { wrap: true }) {
+}
+export const DefaultGenericMiddlewares = [
+    RequestCacheMiddleware,
+    ConfigureInterruptibilityMiddleware,
+    LoggerMiddleware
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS1uYXRpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnBjL21pZGRsZXdhcmUtbmF0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHVEQUF1RDtBQUN2RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sYUFBYSxDQUFBO0FBQzNDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFFcEMsTUFBTSxPQUFPLE9BQVEsU0FBUSxPQUFPLENBQUMsU0FBUyxFQUFXLENBQUMsU0FBUyxFQUFFLEVBQUUsWUFBWSxFQUFFLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO0NBQUc7QUFFdEcsTUFBTSxPQUFPLHNCQUNYLFNBQVEsYUFBYSxDQUFDLEdBQUcsRUFBMEIsQ0FBQyx3QkFBd0IsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQztDQUM3RjtBQUVGLE1BQU0sT0FBTyxtQ0FDWCxTQUFRLGFBQWEsQ0FBQyxHQUFHLEVBQXVDLENBQUMscUNBQXFDLEVBQUU7SUFDdEcsSUFBSSxFQUFFLElBQUk7Q0FDWCxDQUFDO0NBQ0Y7QUFFRixNQUFNLE9BQU8sZ0JBQWlCLFNBQVEsYUFBYSxDQUFDLEdBQUcsRUFBb0IsQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQztDQUFHO0FBRWxILE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFHO0lBQ3ZDLHNCQUFzQjtJQUN0QixtQ0FBbUM7SUFDbkMsZ0JBQWdCO0NBQ1IsQ0FBQSJ9

package/dist/rpc.d.ts

@@ -0,0 +1,7 @@
+export * from "./rpc/generic-middleware.js";
+export * from "./rpc/middleware-api.js";
+export * from "./rpc/middleware-native.js";
+export * from "./rpc/RpcMiddleware.js";
+export * from "./rpc/RpcMiddlewareX.js";
+export * as Middleware from "./rpc.js";
+//# sourceMappingURL=rpc.d.ts.map

package/dist/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AAGvC,OAAO,KAAK,UAAU,MAAM,UAAU,CAAA"}

package/dist/rpc.js

@@ -0,0 +1,9 @@
+// codegen:start {preset: barrel, include: ./rpc/*.ts, nodir: false }
+export * from "./rpc/generic-middleware.js";
+export * from "./rpc/middleware-api.js";
+export * from "./rpc/middleware-native.js";
+export * from "./rpc/RpcMiddleware.js";
+export * from "./rpc/RpcMiddlewareX.js";
+// codegen:end
+export * as Middleware from "./rpc.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnBjLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3JwYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxRUFBcUU7QUFDckUsY0FBYyw2QkFBNkIsQ0FBQTtBQUMzQyxjQUFjLHlCQUF5QixDQUFBO0FBQ3ZDLGNBQWMsNEJBQTRCLENBQUE7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLHlCQUF5QixDQUFBO0FBQ3ZDLGNBQWM7QUFFZCxPQUFPLEtBQUssVUFBVSxNQUFNLFVBQVUsQ0FBQSJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -144,6 +144,10 @@
       "types": "./dist/Tag.d.ts",
       "default": "./dist/Tag.js"
     },
+    "./TypeTest": {
+      "types": "./dist/TypeTest.d.ts",
+      "default": "./dist/TypeTest.js"
+    },
     "./Types": {
       "types": "./dist/Types.d.ts",
       "default": "./dist/Types.js"
@@ -216,6 +220,30 @@
       "types": "./dist/logger.d.ts",
       "default": "./dist/logger.js"
     },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "default": "./dist/rpc.js"
+    },
+    "./rpc/RpcMiddleware": {
+      "types": "./dist/rpc/RpcMiddleware.d.ts",
+      "default": "./dist/rpc/RpcMiddleware.js"
+    },
+    "./rpc/RpcMiddlewareX": {
+      "types": "./dist/rpc/RpcMiddlewareX.d.ts",
+      "default": "./dist/rpc/RpcMiddlewareX.js"
+    },
+    "./rpc/generic-middleware": {
+      "types": "./dist/rpc/generic-middleware.d.ts",
+      "default": "./dist/rpc/generic-middleware.js"
+    },
+    "./rpc/middleware-api": {
+      "types": "./dist/rpc/middleware-api.d.ts",
+      "default": "./dist/rpc/middleware-api.js"
+    },
+    "./rpc/middleware-native": {
+      "types": "./dist/rpc/middleware-native.d.ts",
+      "default": "./dist/rpc/middleware-native.js"
+    },
     "./transform": {
       "types": "./dist/transform.d.ts",
       "default": "./dist/transform.js"

package/src/TypeTest.ts

@@ -0,0 +1,7 @@
+// Nice way to underline types that are only there for type testing, not for production use
+// sadly with unique symbols we get weird issues in app projects.
+// api/src/X/PackList.Controllers.ts:21:1 - error TS4082: Default export of the module has or is using private name 'TypeTestId'
+// export const TypeTestId: unique symbol = Symbol.for("@effect/infra/type-test")
+// export type TypeTestId = typeof TypeTestId
+export const TypeTestId = "effect-app/type-test" as const
+export type TypeTestId = typeof TypeTestId

package/src/rpc/RpcMiddleware.ts

@@ -0,0 +1,254 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type Rpc, RpcMiddleware } from "@effect/rpc"
+import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
+import { type Context, type Effect, type NonEmptyReadonlyArray, type Option, type S, type Schema, type Scope, Unify } from "effect-app"
+import type { AnyService, ContextTagArray, RPCContextMap } from "effect-app/client/req"
+import { type HttpHeaders } from "effect-app/http"
+import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
+
+// updated to support Scope.Scope and Requires
+export interface RpcMiddleware<Provides, E, Requires> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<Provides, E, Scope.Scope | Requires>
+}
+export interface RpcMiddlewareWrap<Provides, E, Requires> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope | Requires>
+  }): Effect.Effect<SuccessValue, E, Scope.Scope | Requires>
+}
+
+export type RpcOptionsOriginal = {
+  readonly wrap?: boolean
+  readonly optional?: boolean
+  readonly failure?: Schema.Schema.All
+  readonly provides?: AnyService
+  readonly requiredForClient?: boolean
+}
+
+export type RpcDynamic<Key extends string, A extends RPCContextMap.Any> = {
+  key: Key
+  settings: A
+}
+
+export type AnyDynamic = { dynamic: RpcDynamic<any, any> }
+
+export type DependsOn = {
+  readonly dependsOn: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export interface RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> extends RpcOptionsOriginal {
+  readonly dynamic: RpcDynamic<Key, A>
+  readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
+
+export interface RpcMiddlewareDynamicWrap<E, R, _Config> {
+  (options: {
+    readonly next: Effect.Effect<SuccessValue, E, Scope.Scope | R>
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps // TODO & { annotations: Context.Context<RequestContextMap<Config>> }
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<
+    SuccessValue,
+    E,
+    Scope.Scope | R
+  >
+}
+
+export interface RpcMiddlewareDynamicNormal<A, E, R, _Config> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps // TODO & { annotations: Context.Context<RequestContextMap<Config>> }
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<
+    Option.Option<A>,
+    E,
+    Scope.Scope | R
+  >
+}
+
+export interface TagClassAny extends Context.Tag<any, any> {
+  readonly [TypeId]: TypeId
+  readonly optional: boolean
+  readonly provides?: Context.Tag<any, any> | ContextTagArray | undefined
+  readonly requires?: Context.Tag<any, any> | ContextTagArray | undefined
+  readonly failure: Schema.Schema.All
+  readonly requiredForClient: boolean
+  readonly wrap: boolean
+  readonly dynamic?: RpcDynamic<any, any> | undefined
+  readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export declare namespace TagClass {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Provides<Options> = Options extends {
+    readonly provides: Context.Tag<any, any>
+    readonly optional?: false
+  } ? Context.Tag.Identifier<Options["provides"]>
+    : Options extends {
+      readonly provides: ContextTagArray
+      readonly optional?: false
+    } ? ContextTagArray.Identifier<Options["provides"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Requires<Options> = Options extends {
+    readonly requires: Context.Tag<any, any>
+  } ? Context.Tag.Identifier<Options["requires"]>
+    : Options extends {
+      readonly requires: ContextTagArray
+    } ? ContextTagArray.Identifier<Options["requires"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Service<Options> = Options extends { readonly provides: Context.Tag<any, any> }
+    ? Context.Tag.Service<Options["provides"]>
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> }
+      ? Options extends { wrap: true } ? void : AnyService.Bla<A["service"]>
+    : Options extends { readonly provides: ContextTagArray }
+      ? Context.Context<ContextTagArray.Identifier<Options["provides"]>>
+    : void
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureSchema<Options> = Options extends
+    { readonly failure: Schema.Schema.All; readonly optional?: false } ? Options["failure"]
+    // actually not, the Failure depends on Dynamic Middleware Configuration!
+    // : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? A["error"]
+    : typeof Schema.Never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Failure<Options> = Options extends
+    { readonly failure: Schema.Schema<infer _A, infer _I, infer _R>; readonly optional?: false } ? _A
+    // actually not, the Failure depends on Dynamic Middleware Configuration!
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureContext<Options> = Schema.Schema.Context<FailureSchema<Options>>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureService<Options> = Optional<Options> extends true ? unknown : Failure<Options>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Optional<Options> = Options extends { readonly optional: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type RequiredForClient<Options> = Options extends { readonly requiredForClient: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Wrap<Options> = Options extends { readonly wrap: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Base<Self, Name extends string, Options, Service> extends Context.Tag<Self, Service> {
+    new(_: never): Context.TagClassShape<Name, Service>
+    readonly [TypeId]: TypeId
+    readonly optional: Optional<Options>
+    readonly failure: FailureSchema<Options>
+    readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"]
+      : Options extends { readonly provides: ContextTagArray } ? Options["provides"]
+      : undefined
+    readonly requires: Options extends { readonly requires: Context.Tag<any, any> } ? Options["requires"]
+      : Options extends { readonly requires: ContextTagArray } ? Options["requires"]
+      : undefined
+    readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
+      : undefined
+    readonly dependsOn: Options extends DependsOn ? Options["dependsOn"] : undefined
+    readonly requiredForClient: RequiredForClient<Options>
+    readonly wrap: Wrap<Options>
+  }
+}
+
+export interface TagClass<
+  Self,
+  Name extends string,
+  Options
+> extends
+  TagClass.Base<
+    Self,
+    Name,
+    Options,
+    Options extends RpcOptionsDynamic<any, any> ? TagClass.Wrap<Options> extends true ? RpcMiddlewareDynamicWrap<
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddlewareDynamicNormal<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>,
+        { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+      >
+      : TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+          TagClass.Provides<Options>,
+          TagClass.Failure<Options>,
+          TagClass.Requires<Options>
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
+      >
+  >
+{}
+
+export const Tag = <Self>() =>
+<
+  const Name extends string,
+  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
+>(
+  id: Name,
+  options?: Options | undefined
+): TagClass<Self, Name, Options> =>
+  class extends RpcMiddleware.Tag<Self>()(id, options as any) {
+    static readonly dynamic = options && "dynamic" in options ? options.dynamic : undefined
+    static readonly dependsOn = options && "dependsOn" in options ? options.dependsOn : undefined
+    static override [Unify.typeSymbol]?: unknown
+    static override [Unify.unifySymbol]?: TagUnify<typeof this>
+    static override [Unify.ignoreSymbol]?: TagUnifyIgnore
+  } as any

package/src/rpc/RpcMiddlewareX.ts

@@ -0,0 +1,70 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type Effect, Layer, type NonEmptyReadonlyArray, Unify } from "effect-app"
+import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
+import { type Service } from "effect/Effect"
+import { type RpcMiddleware, type RpcMiddlewareDynamicNormal, type RpcMiddlewareDynamicWrap, type RpcMiddlewareWrap, type RpcOptionsDynamic, type RpcOptionsOriginal, Tag, type TagClass } from "./RpcMiddleware.js"
+
+/**
+ * @deprecated - RPC groups are defined centrally and re-used between server and client,
+ * so layer implementation details should not be mixed.
+ */
+export const TagService = <Self>() =>
+<
+  const Name extends string,
+  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
+>(
+  id: Name,
+  options?: Options | undefined
+) =>
+<
+  LayerOpts extends {
+    effect: Effect.Effect<
+      Options extends RpcOptionsDynamic<any, any> ? TagClass.Wrap<Options> extends true ? RpcMiddlewareDynamicWrap<
+            TagClass.FailureService<Options>,
+            TagClass.Requires<Options>,
+            { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+          >
+        : RpcMiddlewareDynamicNormal<
+          TagClass.Service<Options>,
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+        : TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+            TagClass.Provides<Options>,
+            TagClass.Failure<Options>,
+            TagClass.Requires<Options>
+          >
+        : RpcMiddleware<
+          TagClass.Service<Options>,
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>
+        >,
+      any,
+      any
+    >
+    dependencies?: NonEmptyReadonlyArray<Layer.Layer.Any>
+  }
+>(opts: LayerOpts): TagClass<Self, Name, Options> & {
+  Default: Layer.Layer<
+    Self,
+    | (LayerOpts extends { effect: Effect<infer _A, infer _E, infer _R> } ? _E
+      : never)
+    | Service.MakeDepsE<LayerOpts>,
+    | Exclude<
+      LayerOpts extends { effect: Effect<infer _A, infer _E, infer _R> } ? _R : never,
+      Service.MakeDepsOut<LayerOpts>
+    >
+    | Service.MakeDepsIn<LayerOpts>
+  >
+} =>
+  class extends Tag<Self>()(id, options as any) {
+    static readonly Default = Layer.scoped(this, opts.effect as any).pipe(
+      Layer.provide([Layer.empty, ...opts.dependencies ?? []])
+    )
+    static override [Unify.typeSymbol]?: unknown
+    static override [Unify.unifySymbol]?: TagUnify<typeof this>
+    static override [Unify.ignoreSymbol]?: TagUnifyIgnore
+  } as any