@floegence/floe-webapp-protocol 0.40.3 → 0.40.5

package/dist/client.d.ts

@@ -1,23 +1,23 @@
 import { type JSX } from 'solid-js';
-import type { Client } from '@floegence/flowersec-core';
-import { type BrowserReconnectConfig } from '@floegence/flowersec-core/browser';
-import { type AutoReconnectConfig, type ConnectionStatus } from '@floegence/flowersec-core/reconnect';
-import type { ProtocolContract, RpcClientLike } from './contract';
+import { type ArtifactSource, type ConnectionControllerOptions, type ConnectionState, type Session } from '@floegence/flowersec-core';
+import type { ProtocolContract } from './contract';
 interface ProtocolContextValue {
-    status: () => ConnectionStatus;
+    status: () => ConnectionState;
     error: () => Error | null;
-    client: () => Client | null;
-    rpcTransport: () => RpcClientLike;
+    session: () => Session | null;
+    rpcTransport: () => Session['rpc'] | null;
     contract: () => ProtocolContract;
     connect: (config: ConnectConfig) => Promise<void>;
-    /** Force a hard reconnect (disconnect old client and build a new one). */
     reconnect: (config?: ConnectConfig) => Promise<void>;
     disconnect: () => void;
 }
-export type { AutoReconnectConfig, ConnectionStatus };
-export type ConnectConfig = BrowserReconnectConfig;
+export type ConnectConfig = Readonly<{
+    source: ArtifactSource;
+    controller?: ConnectionControllerOptions;
+}>;
 export declare function ProtocolProvider(props: {
     children: JSX.Element;
     contract: ProtocolContract;
 }): JSX.Element;
 export declare function useProtocol(): ProtocolContextValue;
+export {};

package/dist/controlplane.d.ts

@@ -1,2 +1,20 @@
-export { type RequestConnectArtifactInput, type RequestEntryConnectArtifactInput, ControlplaneRequestError, requestConnectArtifact, requestEntryConnectArtifact, } from '@floegence/flowersec-core/controlplane';
-export { type ConnectArtifact, assertConnectArtifact, } from '@floegence/flowersec-core/browser';
+import { type Artifact, type JsonObject } from '@floegence/flowersec-core';
+export type RequestConnectArtifactInput = Readonly<{
+    baseUrl: string;
+    endpointId: string;
+    payload?: JsonObject;
+    correlation?: Readonly<{
+        traceId?: string;
+    }>;
+    fetch?: typeof globalThis.fetch;
+}>;
+export type RequestEntryConnectArtifactInput = RequestConnectArtifactInput & Readonly<{
+    entryTicket: string;
+}>;
+export declare class ControlplaneRequestError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare function requestConnectArtifact(input: RequestConnectArtifactInput): Promise<Artifact>;
+export declare function requestEntryConnectArtifact(input: RequestEntryConnectArtifactInput): Promise<Artifact>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { ProtocolProvider, useProtocol, type ConnectionStatus, type ConnectConfig, type AutoReconnectConfig } from './client';
+export { ProtocolProvider, useProtocol, type ConnectConfig } from './client';
 export { useRpc, RpcError, ProtocolNotConnectedError } from './rpc';
-export { assertConnectArtifact, ControlplaneRequestError, requestConnectArtifact, requestEntryConnectArtifact, type ConnectArtifact, type RequestConnectArtifactInput, type RequestEntryConnectArtifactInput, } from './controlplane';
+export { ControlplaneRequestError, requestConnectArtifact, requestEntryConnectArtifact, type RequestConnectArtifactInput, type RequestEntryConnectArtifactInput, } from './controlplane';
 export type { ProtocolContract, RpcClientLike, RpcHelpers } from './contract';

package/dist/index.js

@@ -1,15 +1,13 @@
 import { ProtocolProvider as t, useProtocol as e } from "./index2.js";
-import { ProtocolNotConnectedError as n, RpcError as f, useRpc as p } from "./index3.js";
-import { ControlplaneRequestError as a, requestConnectArtifact as l, requestEntryConnectArtifact as u } from "@floegence/flowersec-core/controlplane";
-import { assertConnectArtifact as i } from "@floegence/flowersec-core/browser";
+import { ProtocolNotConnectedError as n, RpcError as p, useRpc as f } from "./index3.js";
+import { ControlplaneRequestError as s, requestConnectArtifact as u, requestEntryConnectArtifact as C } from "./index4.js";
 export {
-  a as ControlplaneRequestError,
+  s as ControlplaneRequestError,
   n as ProtocolNotConnectedError,
   t as ProtocolProvider,
-  f as RpcError,
-  i as assertConnectArtifact,
-  l as requestConnectArtifact,
-  u as requestEntryConnectArtifact,
+  p as RpcError,
+  u as requestConnectArtifact,
+  C as requestEntryConnectArtifact,
   e as useProtocol,
-  p as useRpc
+  f as useRpc
 };

package/dist/index2.js

@@ -1,83 +1,67 @@
-import { createContext as P, onCleanup as C, createComponent as x, useContext as b } from "solid-js";
-import { createStore as v } from "solid-js/store";
-import { createBrowserReconnectConfig as A } from "@floegence/flowersec-core/browser";
-import { RpcProxy as N } from "@floegence/flowersec-core/rpc";
-import { createReconnectManager as R } from "@floegence/flowersec-core/reconnect";
-const h = P();
-function W(o) {
-  const r = R(), s = r.state(), [a, p] = v({
-    status: s.status,
-    error: s.error,
-    client: s.client
-  }), m = o.contract, c = new N(), w = {
-    rpc: {
-      call: (t, n) => c.call(t, n),
-      notify: (t, n) => c.notify(t, n),
-      onNotify: (t, n) => c.onNotify(t, n)
-    }
-  };
-  s.client && c.attach(s.client.rpc);
-  const y = r.subscribe((t) => {
-    t.client ? c.attach(t.client.rpc) : c.detach(), p({
-      status: t.status,
-      error: t.error,
-      client: t.client
+import { createContext as C, onCleanup as v, createComponent as P, useContext as b } from "solid-js";
+import { createStore as h } from "solid-js/store";
+import "@floegence/flowersec-core";
+import { createConnectionController as y } from "@floegence/flowersec-core/browser";
+const f = C();
+function T(o) {
+  const [s, i] = h({
+    status: "idle",
+    error: null,
+    session: null
+  }), d = o.contract;
+  let e = null, c = null, l = null, n = null;
+  const w = (t) => {
+    const r = t.failure;
+    i({
+      status: t.state,
+      session: t.currentSession ?? null,
+      error: r === void 0 ? null : new Error(`${r.phase}:${r.code}`)
     });
-  });
-  let l = null, u = null, e = null;
-  const f = (t) => ((l !== t || u === null) && (l = t, u = A(t)), u), d = async (t, n) => {
-    if (n === "hard") {
-      await r.connect(t);
-      return;
-    }
-    await r.connectIfNeeded(t);
-  }, g = {
-    status: () => a.status,
-    error: () => a.error,
-    client: () => a.client,
-    rpcTransport: () => w,
-    contract: () => m,
-    connect: async (t) => {
-      const n = f(t), i = r.state();
-      if (!(i.status === "connected" && i.client) && !(i.status === "connecting" && !e)) {
-        if (e) {
-          await e;
-          return;
-        }
-        e = d(n, "if_needed").finally(() => {
-          e = null;
-        }), await e;
-      }
-    },
+  }, u = async () => {
+    c?.(), c = null;
+    const t = e;
+    e = null, t && await t.close(), i({
+      status: "idle",
+      session: null,
+      error: null
+    });
+  }, m = async (t) => {
+    await u(), l = t, e = y(t.source, t.controller), c = e.subscribe(w), e.start(), await e.waitForSession();
+  }, a = async (t) => n || (n = (async () => {
+    e && l?.source === t.source && e.state === "connected" || await m(t);
+  })().finally(() => {
+    n = null;
+  }), n), p = {
+    status: () => s.status,
+    error: () => s.error,
+    session: () => s.session,
+    rpcTransport: () => s.session?.rpc ?? null,
+    contract: () => d,
+    connect: a,
     reconnect: async (t) => {
-      const n = t ?? l;
-      if (!n)
-        throw new Error("reconnect() requires a config before the first connect() call");
-      const i = f(n);
-      return e || (e = d(i, "hard").finally(() => {
-        e = null;
-      }), e);
+      const r = t ?? l;
+      if (!r) throw new Error("reconnect() requires a config before the first connect() call");
+      await a(r);
     },
     disconnect: () => {
-      c.detach(), r.disconnect();
+      u();
     }
   };
-  return C(() => {
-    y(), c.detach(), r.disconnect();
-  }), x(h.Provider, {
-    value: g,
+  return v(() => {
+    c?.(), e?.close();
+  }), P(f.Provider, {
+    value: p,
     get children() {
       return o.children;
     }
   });
 }
-function _() {
-  const o = b(h);
-  if (!o)
-    throw new Error("useProtocol must be used within a ProtocolProvider");
+function g() {
+  const o = b(f);
+  if (!o) throw new Error("useProtocol must be used within a ProtocolProvider");
   return o;
 }
 export {
-  W as ProtocolProvider,
-  _ as useProtocol
+  T as ProtocolProvider,
+  g as useProtocol
 };

package/dist/index3.js

@@ -1,6 +1,5 @@
-import { useProtocol as y } from "./index2.js";
-import { RpcProxyDetachedError as d } from "@floegence/flowersec-core/rpc";
-class u extends Error {
+import { useProtocol as u } from "./index2.js";
+class d extends Error {
   constructor() {
     super("Not connected"), this.name = "ProtocolNotConnectedError";
   }
@@ -8,53 +7,58 @@ class u extends Error {
 class p extends Error {
   typeId;
   code;
-  constructor(t) {
-    super(t.message ?? `RPC error: ${t.code}`, { cause: t.cause }), this.name = "RpcError", this.typeId = t.typeId, this.code = t.code;
+  constructor(o) {
+    super(o.message ?? `RPC error: ${o.code}`, { cause: o.cause }), this.name = "RpcError", this.typeId = o.typeId, this.code = o.code;
   }
 }
-function h(c) {
-  const t = async (r, e) => {
-    const a = c.rpcTransport();
-    let o;
+function y(c) {
+  const o = async (r, e) => {
+    const n = c.rpcTransport();
+    if (!n) throw new d();
+    let t;
     try {
-      o = await a.rpc.call(r, e);
-    } catch (n) {
-      throw n instanceof d ? new u() : new p({ typeId: r, code: -1, message: "RPC transport error", cause: n });
+      t = await n.call(r, e, (s) => s);
+    } catch (s) {
+      throw new p({ typeId: r, code: -1, message: "RPC transport error", cause: s });
     }
-    if (o.error)
+    if (!t.ok)
       throw new p({
         typeId: r,
-        code: o.error.code,
-        message: o.error.message ?? `RPC error: ${o.error.code}`,
-        cause: o.error
+        code: t.error.code,
+        message: t.error.message ?? `RPC error: ${t.error.code}`,
+        cause: t.error
       });
-    return o.payload;
-  }, s = async (r, e, a) => {
-    const o = c.rpcTransport();
+    return t.payload;
+  }, a = async (r, e, n) => {
+    const t = c.rpcTransport();
+    if (!t) {
+      if (n.detached === "ignore") return;
+      throw new d();
+    }
     try {
-      await o.rpc.notify(r, e);
-    } catch (n) {
-      if (n instanceof d) {
-        if (a.detached === "ignore") return;
-        throw new u();
-      }
-      throw new p({ typeId: r, code: -1, message: "RPC notify transport error", cause: n });
+      await t.notify(r, e);
+    } catch (s) {
+      throw new p({ typeId: r, code: -1, message: "RPC notify transport error", cause: s });
     }
   };
-  return { call: t, notify: async (r, e) => {
-    await s(r, e, { detached: "throw" });
+  return { call: o, notify: async (r, e) => {
+    await a(r, e, { detached: "throw" });
   }, notifyBestEffort: async (r, e) => {
-    await s(r, e, { detached: "ignore" });
-  }, onNotify: (r, e) => c.rpcTransport().rpc.onNotify(r, (o) => {
-    e(o);
-  }) };
+    await a(r, e, { detached: "ignore" });
+  }, onNotify: (r, e) => {
+    const n = c.rpcTransport();
+    return n ? n.onNotify(r, (t) => {
+      e(t);
+    }) : () => {
+    };
+  } };
 }
-function E(c) {
-  const t = y(), s = c?.contract ?? t.contract(), i = h(t), f = s.createRpc(i);
+function l(c) {
+  const o = u(), a = c?.contract ?? o.contract(), i = y(o), f = a.createRpc(i);
   return Object.assign(f, i);
 }
 export {
-  u as ProtocolNotConnectedError,
+  d as ProtocolNotConnectedError,
   p as RpcError,
-  E as useRpc
+  l as useRpc
 };

package/dist/index4.js

@@ -0,0 +1,42 @@
+import { parseArtifact as f } from "@floegence/flowersec-core";
+class a extends Error {
+  constructor(c, o, e) {
+    super(e), this.status = c, this.code = o, this.name = "ControlplaneRequestError";
+  }
+}
+async function i(t) {
+  const c = t.fetch ?? globalThis.fetch, o = new URL(t.baseUrl);
+  if (o.protocol !== "https:") throw new a(0, "transport_policy_denied", "controlplane transport policy denied");
+  const e = "entryTicket" in t, s = new URL(`/v1/connect/artifact${e ? "/entry" : ""}`, o).toString(), l = {
+    endpoint_id: t.endpointId,
+    ...t.payload === void 0 ? {} : { payload: t.payload },
+    ...!e && t.correlation === void 0 ? {} : e ? {} : { correlation: { trace_id: t.correlation?.traceId } }
+  }, r = await c(s, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      ...e ? { authorization: `Bearer ${t.entryTicket}` } : {}
+    },
+    body: JSON.stringify(l),
+    credentials: "omit",
+    redirect: "error"
+  });
+  if (!r.ok) throw new a(r.status, "request_failed", `controlplane request failed: ${r.status}`);
+  const n = await r.json();
+  if (n.connect_artifact === void 0)
+    throw new a(200, "invalid_request", "Invalid controlplane response: missing `connect_artifact`");
+  const d = typeof n.connect_artifact == "string" || n.connect_artifact instanceof Uint8Array ? n.connect_artifact : JSON.stringify(n.connect_artifact);
+  return f(d);
+}
+function y(t) {
+  return i(t);
+}
+function h(t) {
+  return i(t);
+}
+export {
+  a as ControlplaneRequestError,
+  y as requestConnectArtifact,
+  h as requestEntryConnectArtifact
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-protocol",
-  "version": "0.40.3",
+  "version": "0.40.5",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -33,7 +33,7 @@
     "solid-js": "^1.8.0"
   },
   "dependencies": {
-    "@floegence/flowersec-core": "^0.27.0"
+    "@floegence/flowersec-core": "2.0.0"
   },
   "devDependencies": {
     "solid-js": "^1.9.11",