t3code-cli 0.5.0 → 0.5.1

package/src/rpc/layer.ts

@@ -6,14 +6,13 @@ import * as Option from "effect/Option";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
-import * as NodeSocket from "@effect/platform-node/NodeSocket";
 import { HttpClientRequest } from "effect/unstable/http";
 import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
 import * as Socket from "effect/unstable/socket/Socket";
 
-import { T3Auth } from "../auth/service.ts";
-import { T3Config } from "../config/service.ts";
-import { toWebSocketEndpointUrl } from "../config/url.ts";
+import { T3AuthTransport } from "../auth/transport.ts";
+import { T3CodeConnectionProvider } from "../connection/service.ts";
+import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url.ts";
 import { CliWsRpcGroup } from "./ws-group.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
@@ -27,15 +26,19 @@ type Connection = {
 };
 
 export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
-  const config = yield* T3Config;
-  const auth = yield* T3Auth;
+  const connectionProvider = yield* T3CodeConnectionProvider;
+  const authTransport = yield* T3AuthTransport;
+  const webSocketConstructor = yield* Socket.WebSocketConstructor;
   const parentScope = yield* Scope.Scope;
   const connection = yield* SynchronizedRef.make(Option.none<Connection>());
   const openConnection = Effect.fn("T3RpcLive.openConnection")(function* () {
     const scope = yield* Scope.fork(parentScope);
     return yield* Effect.gen(function* () {
-      const url = yield* makeWsUrl({ auth, config });
-      const protocol = yield* Layer.buildWithScope(makeProtocolLayer(url), scope);
+      const url = yield* makeWsUrl({ authTransport, connectionProvider });
+      const protocol = yield* Layer.buildWithScope(
+        makeProtocolLayer(url, webSocketConstructor),
+        scope,
+      );
       const client = yield* makeClient.pipe(
         Effect.provide(protocol),
         Effect.provideService(Scope.Scope, scope),
@@ -72,21 +75,28 @@ export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
 });
 
 const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
-  readonly config: T3Config["Service"];
-  readonly auth: T3Auth["Service"];
+  readonly authTransport: T3AuthTransport["Service"];
+  readonly connectionProvider: T3CodeConnectionProvider["Service"];
 }) {
-  const resolved = yield* input.config.resolve();
-  const wsTicket = yield* input.auth.issueWebSocketTicket();
-  const wsUrl = yield* toWebSocketEndpointUrl(resolved.url, "/ws");
+  const connection = yield* input.connectionProvider.get;
+  const origin = yield* normalizeHttpBaseUrl(connection.origin.url);
+  const wsTicket = yield* input.authTransport.issueWebSocketTicket({
+    url: origin,
+    token: connection.auth.token,
+  });
+  const wsUrl = yield* toWebSocketEndpointUrl(origin, "/ws");
   const request = HttpClientRequest.get(wsUrl).pipe(
     HttpClientRequest.setUrlParam("wsTicket", wsTicket.ticket),
   );
   return Option.getOrThrow(HttpClientRequest.toUrl(request)).toString();
 });
 
-function makeProtocolLayer(url: string) {
+function makeProtocolLayer(
+  url: string,
+  webSocketConstructor: Socket.WebSocketConstructor["Service"],
+) {
   const socketLayer = Socket.layerWebSocket(url).pipe(
-    Layer.provide(NodeSocket.layerWebSocketConstructor),
+    Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)),
   );
   return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(
     Layer.provide(socketLayer),

package/src/runtime.ts

@@ -1,12 +1,18 @@
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 
 import { T3AuthLive } from "./auth/layer.ts";
 import { T3LocalAuthLive } from "./auth/local.ts";
+import { T3LocalAuthOriginLive } from "./auth/local-origin.ts";
+import { T3LocalAuthTokenLive } from "./auth/local-token.ts";
 import { T3AuthPairingLive } from "./auth/pairing.ts";
 import { T3AuthTransportLive } from "./auth/transport.ts";
+import { T3CodeConnectionError } from "./connection/error.ts";
+import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "./connection/service.ts";
 import { T3ConfigLive } from "./config/layer.ts";
+import { T3Config } from "./config/service.ts";
 import { T3ApplicationLive } from "./application/layer.ts";
 import { T3OrchestrationLive } from "./orchestration/layer.ts";
 import { T3RpcLive } from "./rpc/layer.ts";
@@ -15,15 +21,49 @@ import { NodeSqlClientFactoryLive } from "./sql/node-sqlite-client.ts";
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
 );
-export const T3LocalAuthLayer = T3LocalAuthLive.pipe(Layer.provide(NodeSqlClientFactoryLive));
+export const T3LocalAuthOriginLayer = T3LocalAuthOriginLive;
+export const T3LocalAuthTokenLayer = T3LocalAuthTokenLive.pipe(
+  Layer.provide(NodeSqlClientFactoryLive),
+);
+export const T3LocalAuthLayer = T3LocalAuthLive.pipe(
+  Layer.provide(Layer.mergeAll(T3LocalAuthOriginLayer, T3LocalAuthTokenLayer)),
+);
 export const T3AuthPairingLayer = T3AuthPairingLive.pipe(Layer.provide(T3AuthTransportLayer));
 export const T3AuthLayer = T3AuthLive.pipe(
   Layer.provide(
     Layer.mergeAll(T3ConfigLive, T3AuthTransportLayer, T3LocalAuthLayer, T3AuthPairingLayer),
   ),
 );
+const T3ConfigConnectionProviderLayer = Layer.effect(
+  T3CodeConnectionProvider,
+  Effect.gen(function* () {
+    const config = yield* T3Config;
+    return makeT3CodeConnectionProvider(
+      config.resolve().pipe(
+        Effect.map((resolved) => ({
+          origin: { url: resolved.url },
+          auth: { token: resolved.token },
+        })),
+        Effect.mapError(
+          (error) =>
+            new T3CodeConnectionError({
+              message: "failed to resolve T3 Code connection from CLI config",
+              cause: error,
+            }),
+        ),
+      ),
+    );
+  }),
+).pipe(Layer.provide(T3ConfigLive));
+
 const T3RpcLayer = T3RpcLive.pipe(
-  Layer.provide(Layer.mergeAll(T3ConfigLive, T3AuthLayer, NodeSocket.layerWebSocketConstructor)),
+  Layer.provide(
+    Layer.mergeAll(
+      T3ConfigConnectionProviderLayer,
+      T3AuthTransportLayer,
+      NodeSocket.layerWebSocketConstructor,
+    ),
+  ),
 );
 const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
 const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));