@opentunnel/client 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentunnel/client",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "OpenTunnel SDK for Bun: expose local services through a blind TLS tunnel",
   "license": "MIT",
   "repository": {
@@ -28,8 +28,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@opentunnel/protocol": "0.1.0",
-    "effect": "4.0.0-beta.42"
+    "@opentunnel/protocol": "0.2.0",
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
     "@peculiar/x509": "2.0.0",

package/src/effect/api.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, ServiceMap } from "effect";
+import { Effect, Layer, Context } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
 import { HttpApiClient } from "effect/unstable/httpapi";
 import { Api } from "@opentunnel/protocol/api/api";
@@ -11,7 +11,7 @@ interface OpenTunnelApi {
   readonly authorized: (token: Tunnel.Token) => Effect.Effect<Client>;
 }
 
-export class OpenTunnelApiClient extends ServiceMap.Service<OpenTunnelApiClient, OpenTunnelApi>()(
+export class OpenTunnelApiClient extends Context.Service<OpenTunnelApiClient, OpenTunnelApi>()(
   "@opentunnel/client/OpenTunnelApiClient",
 ) {
   static layer(options: { readonly api: URL | string }) {

package/src/effect/client.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Layer, Queue, ServiceMap, Stream } from "effect";
+import { Cause, Effect, Layer, Queue, Context, Stream } from "effect";
 import { CSR } from "@opentunnel/protocol/csr";
 import { Tunnel } from "@opentunnel/protocol/tunnel";
 import { OpenTunnelApiClient } from "./api.js";
@@ -33,7 +33,7 @@ export interface OpenTunnelClientOptions {
   readonly storage?: Storage;
 }
 
-export class OpenTunnelClient extends ServiceMap.Service<
+export class OpenTunnelClient extends Context.Service<
   OpenTunnelClient,
   OpenTunnelEffectClient
 >()("@opentunnel/client/OpenTunnelClient") {
@@ -56,10 +56,10 @@ export class OpenTunnelClient extends ServiceMap.Service<
           readonly pending: OpenTunnelPendingIdentity;
           readonly onProgress?: (stage: OpenTunnelProvisionStage) => void;
         }) {
-          const authorized = yield* api.authorized(Tunnel.Token.makeUnsafe(options.pending.token));
+          const authorized = yield* api.authorized(Tunnel.Token.make(options.pending.token));
           yield* Effect.sync(() => options.onProgress?.("requesting-certificate"));
           yield* authorized.tunnel["tunnel.bindCertificate"]({
-            params: { id: Tunnel.ID.makeUnsafe(options.pending.id) },
+            params: { id: Tunnel.ID.make(options.pending.id) },
             payload: { csr: options.pending.csr as CSR.Raw },
           }).pipe(
             // A resumed provision may already have an issuance in flight.
@@ -71,7 +71,7 @@ export class OpenTunnelClient extends ServiceMap.Service<
             while (true) {
               yield* Effect.sync(() => options.onProgress?.("waiting-certificate"));
               const value = yield* authorized.tunnel["tunnel.getCertificate"]({
-                params: { id: Tunnel.ID.makeUnsafe(options.pending.id) },
+                params: { id: Tunnel.ID.make(options.pending.id) },
               }).pipe(
                 Effect.mapError((cause) => clientError("Failed to read certificate", cause)),
               );
@@ -176,9 +176,9 @@ export class OpenTunnelClient extends ServiceMap.Service<
         ) {
           const existing = yield* get(input);
           if (!existing) return yield* create(input);
-          const authorized = yield* api.authorized(Tunnel.Token.makeUnsafe(existing.token));
+          const authorized = yield* api.authorized(Tunnel.Token.make(existing.token));
           const certificate = yield* authorized.tunnel["tunnel.getCertificate"]({
-            params: { id: Tunnel.ID.makeUnsafe(existing.id) },
+            params: { id: Tunnel.ID.make(existing.id) },
           }).pipe(
             Effect.mapError((cause) => clientError("Failed to read certificate", cause)),
           );
@@ -197,9 +197,9 @@ export class OpenTunnelClient extends ServiceMap.Service<
           if (state.type !== "failed") return existing;
           return yield* provision({
             profile: profileName(input),
-            id: Tunnel.ID.makeUnsafe(existing.id),
+            id: Tunnel.ID.make(existing.id),
             hostname: existing.hostname,
-            token: Tunnel.Token.makeUnsafe(existing.token),
+            token: Tunnel.Token.make(existing.token),
           });
         });
 
@@ -235,9 +235,9 @@ export class OpenTunnelClient extends ServiceMap.Service<
               const profile = profileName(input);
               const identity = yield* storage.load(profile);
               if (!identity) return;
-              const authorized = yield* api.authorized(Tunnel.Token.makeUnsafe(identity.token));
+              const authorized = yield* api.authorized(Tunnel.Token.make(identity.token));
               yield* authorized.tunnel["tunnel.remove"]({
-                params: { id: Tunnel.ID.makeUnsafe(identity.id) },
+                params: { id: Tunnel.ID.make(identity.id) },
               }).pipe(
                 Effect.mapError((cause) => clientError("Failed to remove tunnel", cause)),
               );

package/src/effect/errors.ts

@@ -1,13 +1,13 @@
 import { Schema } from "effect";
 
-export class OpenTunnelClientError extends Schema.TaggedErrorClass<OpenTunnelClientError>()(
+export class OpenTunnelClientError extends Schema.TaggedError<OpenTunnelClientError>()(
   "OpenTunnelClientError",
-  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+  { message: Schema.String, cause: Schema.optional(Schema.Defect()) },
 ) {}
 
-export class OpenTunnelStorageError extends Schema.TaggedErrorClass<OpenTunnelStorageError>()(
+export class OpenTunnelStorageError extends Schema.TaggedError<OpenTunnelStorageError>()(
   "OpenTunnelStorageError",
-  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+  { message: Schema.String, cause: Schema.optional(Schema.Defect()) },
 ) {}
 
 export type OpenTunnelError = OpenTunnelClientError | OpenTunnelStorageError;

package/src/promise/client.ts

@@ -78,7 +78,7 @@ export function create(options: OpenTunnelClientOptions = {}): OpenTunnelPromise
   const runtime = ManagedRuntime.make(OpenTunnelClient.layer(effectOptions));
   const withClient = <A, E>(
     f: (client: OpenTunnelClient["Service"]) => Effect.Effect<A, E>,
-  ) => runtime.runPromise(Effect.flatMap(OpenTunnelClient.asEffect(), f));
+  ) => runtime.runPromise(Effect.flatMap(OpenTunnelClient, f));
 
   return {
     profile: { list: () => withClient((client) => client.profile.list()) },
@@ -95,7 +95,7 @@ export function create(options: OpenTunnelClientOptions = {}): OpenTunnelPromise
         const closeScope = () => runtime.runPromise(Scope.close(scope, Exit.void));
         const connection = await runtime
           .runPromise(
-            Effect.flatMap(OpenTunnelClient.asEffect(), (client) => client.tunnel.connect(input)).pipe(
+            Effect.flatMap(OpenTunnelClient, (client) => client.tunnel.connect(input)).pipe(
               Effect.provideService(Scope.Scope, scope),
             ),
           )