@kubun/plugin-p2p 0.8.3 → 0.10.0

package/lib/types.d.ts

@@ -3,6 +3,15 @@ import type { SyncDirection, SyncProtocol } from './protocol.js';
 import type { PeerConfig, PeerConfigWithID } from './sync/peer-registry.js';
 import type { SyncScope } from './sync/sync-client.js';
 import type { SyncEvent, SyncStatus } from './sync/sync-manager.js';
+/**
+ * Receiver storage mode for incoming peer mutations.
+ * - `'persist'` — store every doc that passes catalog/group checks. Access
+ *   enforced at query time; unreadable docs remain in DB but filtered.
+ * - `'drop'` — apply read-access check at receive time using the local
+ *   peer's own DID as viewer. Mutations the local peer cannot read are
+ *   not persisted.
+ */
+export type StoreUnreadableMode = 'persist' | 'drop';
 export type GroupData = {
     id: string;
     name: string;
@@ -37,6 +46,14 @@ export type CatalogData = {
     filterCriteria: string;
     createdAt: string;
 };
+export type HubData = {
+    id: string;
+    label: string | null;
+    url: string;
+    serverDID: string | null;
+    createdAt: string;
+    updatedAt: string | null;
+};
 export type InviteToGroupData = {
     invitePayload: string;
     groupID: string;
@@ -76,6 +93,10 @@ export type GroupRequestContext = {
     create: (input: {
         name: string;
         description?: string;
+        hubs?: Array<{
+            url: string;
+            serverDID?: string | null;
+        }>;
     }) => Promise<GroupData>;
     list: () => Promise<Array<GroupData>>;
     get: (id: string) => Promise<GroupData | null>;
@@ -94,7 +115,15 @@ export type GroupRequestContext = {
         filterCriteria: string;
     }) => Promise<CatalogData>;
     listCatalogs: (ownerDID?: string) => Promise<Array<CatalogData>>;
-    invite: (groupID: string, joinRequest: string) => Promise<InviteToGroupData>;
+    /**
+     * Build an invite payload for a join request.
+     *
+     * `grants` are stringified write-capability JWTs the caller wants the joiner
+     * to hold immediately on join. `revocations` are signed revocation JWTs the
+     * caller wants the joiner to apply immediately — only verified ones travel;
+     * pending revocations (cap not yet known by the inviter) do not.
+     */
+    invite: (groupID: string, joinRequest: string, grants?: Array<string>, revocations?: Array<string>) => Promise<InviteToGroupData>;
     join: (invitePayload: string, joinRequestPayload: string) => Promise<JoinGroupData>;
     leave: (groupID: string) => Promise<LeaveGroupData>;
     removeMember: (groupID: string, memberDID: string) => Promise<RemoveGroupMemberData>;
@@ -108,6 +137,53 @@ export type GroupRequestContext = {
     deleteCatalog: (catalogID: string) => Promise<DeleteCatalogData>;
     deleteCircle: (circleID: string) => Promise<DeleteCircleData>;
     removeCircleMember: (circleID: string, memberDID: string) => Promise<RemoveCircleMemberData>;
+    /**
+     * Mint a `document/write` capability granting `to` write access on resources
+     * matching `res`. Token is stored grantor-side, broadcast to the group, and
+     * returned for direct delivery.
+     *
+     * `res` is a URN. Most-specific wins; broader URNs grant strictly more:
+     *   - `urn:kubun:document:<docID>` — single doc
+     *   - `urn:kubun:model:<modelID>` — every doc of that model owned by the grantor
+     *   - `urn:kubun:model:<interfaceID>` — every doc of every model implementing
+     *     the interface (footgun: a grant on a widely-implemented interface like
+     *     `Owned` or `Timestamped` becomes a near-wildcard)
+     *   - `urn:kubun:user:<DID>` — every doc owned by that DID (the grantor)
+     *   - `*` — every doc the grantor owns, present and future
+     *
+     * Prefer the narrowest URN that satisfies the use case. Broad grants combine
+     * with the long default `exp` (30 days) to expand the blast radius of a
+     * leaked or misdirected token.
+     */
+    grantWriteCapability: (params: {
+        to: string;
+        res: string;
+        groupID: string;
+        expiresIn?: number;
+    }) => Promise<string>;
+    /**
+     * Revoke a previously-granted `document/write` capability by its `jti`.
+     *
+     * Revocation is binary: once a peer learns of the revocation, every
+     * mutation that authenticates via this `jti` is denied. The check is
+     * reactive, not retroactive — mutations already applied locally stay
+     * applied; only future writes carrying the revoked `jti` are gated.
+     *
+     * Only the original capability issuer may revoke it. The resolver looks up
+     * the capability locally and rejects:
+     *   - `REVOCATION_CAP_UNKNOWN` when no row matches the `jti` on this peer
+     *     (multi-device-grantor case, where the issuing device is not the one
+     *     calling `revokeCapability`, is not yet supported).
+     *   - `REVOCATION_UNAUTHORIZED` when the viewer is not the capability's
+     *     issuer.
+     *
+     * Returns the boolean reported by the store: `true` when the revocation
+     * row was newly written (or materially changed), `false` on an idempotent
+     * no-op (already revoked at an equal or newer HLC).
+     */
+    revokeCapability: (params: {
+        jti: string;
+    }) => Promise<boolean>;
 };
 export type SyncRequestContext = {
     addPeer: (config: PeerConfig) => Promise<void>;
@@ -123,10 +199,79 @@ export type P2PJoinRequestContext = {
         group: GroupData | null;
     }>;
 };
+export type CreateHubInput = {
+    url: string;
+    label?: string | null;
+    serverDID?: string | null;
+};
+export type UpdateHubInput = {
+    id: string;
+    url?: string;
+    label?: string | null;
+    serverDID?: string | null;
+};
+export type DeleteHubData = {
+    success: boolean;
+    boundGroupIDs: Array<string>;
+};
+export type HubRequestContext = {
+    list: () => Promise<Array<HubData>>;
+    get: (id: string) => Promise<HubData | null>;
+    create: (input: CreateHubInput) => Promise<HubData>;
+    update: (input: UpdateHubInput) => Promise<HubData>;
+    delete: (id: string, force?: boolean) => Promise<DeleteHubData>;
+    bind: (params: {
+        hubID: string;
+        groupID: string;
+    }) => Promise<boolean>;
+    unbind: (params: {
+        hubID: string;
+        groupID: string;
+    }) => Promise<boolean>;
+    listByGroup: (groupID: string) => Promise<Array<HubData>>;
+    listGroups: (hubID: string) => Promise<Array<GroupData>>;
+};
+export type DelegationData = {
+    jwt: string;
+    jti: string;
+    grantor: string;
+    audience: string;
+    resource: string;
+    exp: number;
+};
+export type DelegationTokenCovers = {
+    modelID?: string | null;
+    docID?: string | null;
+};
+export type ListOwnDelegationTokensParams = {
+    viewerDID: string;
+    grantor?: string | null;
+    covers?: DelegationTokenCovers | null;
+};
+export type RevokedDelegationData = {
+    jti: string;
+    grantor: string;
+    audience: string;
+    revokerDID: string;
+    revokedAt: number;
+    verifiedAt: number;
+    capExp: number | null;
+    groupID: string;
+};
+export type ListOwnRevokedTokensParams = {
+    viewerDID: string;
+    grantor?: string | null;
+};
+export type DelegationRequestContext = {
+    listOwnTokens: (params: ListOwnDelegationTokensParams) => Promise<Array<DelegationData>>;
+    listOwnRevokedTokens: (params: ListOwnRevokedTokensParams) => Promise<Array<RevokedDelegationData>>;
+};
 export type P2PContext = {
     group: GroupRequestContext;
     sync: SyncRequestContext;
     join: P2PJoinRequestContext;
+    hub: HubRequestContext;
+    delegation: DelegationRequestContext;
 };
 declare module '@kubun/graphql' {
     interface PluginContextMap {
@@ -143,6 +288,11 @@ export type SyncSessionResult = {
 export type SyncPluginAPI = {
     /** Resolves when the HTTP sync transport is registered (only present when http option is enabled). */
     syncReady?: Promise<void>;
+    /**
+     * Resolves when hub relay setup completes. `DISABLED_HUB.ready` is already
+     * resolved when the `hub` plugin option is absent.
+     */
+    hubReady: Promise<void>;
     addPeer(config: PeerConfig): Promise<void>;
     removePeer(peerDID: string): Promise<void>;
     listPeers(): Promise<Array<PeerConfigWithID>>;

package/lib/util/mutex.d.ts

@@ -0,0 +1,4 @@
+export type Mutex = {
+    run<T>(fn: () => Promise<T>): Promise<T>;
+};
+export declare function createMutex(): Mutex;

package/lib/util/mutex.js

@@ -0,0 +1 @@
+export function createMutex(){let e=Promise.resolve();return{run(t){let r=e.then(()=>t());return e=r.catch(()=>{}),r}}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -14,47 +14,50 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/async": "^0.14.1",
-    "@enkaku/capability": "^0.14.0",
-    "@enkaku/client": "^0.14.4",
-    "@enkaku/codec": "^0.14.0",
-    "@enkaku/event": "^0.14.1",
-    "@enkaku/generator": "^0.14.0",
-    "@enkaku/group": "^0.14.6",
-    "@enkaku/http-client-transport": "^0.14.3",
-    "@enkaku/http-server-transport": "^0.14.2",
-    "@enkaku/hub-protocol": "^0.14.0",
-    "@enkaku/protocol": "^0.14.0",
-    "@enkaku/runtime": "^0.14.0",
-    "@enkaku/schema": "^0.14.0",
-    "@enkaku/server": "^0.14.4",
-    "@enkaku/stream": "^0.14.1",
-    "@enkaku/token": "0.14.1",
-    "@enkaku/transport": "0.14.1",
+    "@enkaku/async": "^0.16.0",
+    "@enkaku/capability": "^0.16.0",
+    "@enkaku/client": "^0.16.0",
+    "@enkaku/codec": "^0.16.0",
+    "@enkaku/event": "^0.16.0",
+    "@enkaku/generator": "^0.16.0",
+    "@enkaku/group": "^0.16.1",
+    "@enkaku/http-client-transport": "^0.16.0",
+    "@enkaku/http-server-transport": "^0.16.0",
+    "@enkaku/hub-protocol": "^0.16.0",
+    "@enkaku/hub-tunnel": "^0.16.0",
+    "@enkaku/protocol": "^0.16.0",
+    "@enkaku/runtime": "^0.16.0",
+    "@enkaku/schema": "^0.16.0",
+    "@enkaku/server": "^0.16.0",
+    "@enkaku/stream": "^0.16.0",
+    "@enkaku/token": "^0.16.0",
+    "@enkaku/transport": "^0.16.0",
     "@noble/hashes": "^2.2.0",
     "graphql": "^16.13.2",
-    "kysely": "^0.28.16",
-    "@kubun/client": "^0.8.0",
-    "@kubun/db": "^0.8.1",
-    "@kubun/engine": "^0.8.3",
-    "@kubun/db-adapter": "^0.8.1",
-    "@kubun/store-p2p": "^0.8.0",
-    "@kubun/store-graph": "^0.8.1",
-    "@kubun/graphql": "^0.8.2",
-    "@kubun/hlc": "^0.8.0",
-    "@kubun/mutation": "^0.8.1",
-    "@kubun/protocol": "^0.8.1",
-    "@kubun/id": "^0.8.0",
-    "@kubun/logger": "^0.8.0"
+    "kysely": "^0.29.2",
+    "@kubun/client": "^0.10.0",
+    "@kubun/db": "^0.10.0",
+    "@kubun/store-graph": "^0.10.0",
+    "@kubun/graphql": "^0.10.0",
+    "@kubun/db-adapter": "^0.10.0",
+    "@kubun/hlc": "^0.10.0",
+    "@kubun/id": "^0.10.0",
+    "@kubun/engine": "^0.10.0",
+    "@kubun/store-p2p": "^0.10.0",
+    "@kubun/mutation": "^0.10.0",
+    "@kubun/logger": "^0.10.0",
+    "@kubun/protocol": "^0.10.0"
   },
   "devDependencies": {
-    "@enkaku/hub-server": "^0.14.1",
+    "@enkaku/hub-server": "^0.16.0",
     "get-port": "^7.2.0",
-    "@kubun/db-better-sqlite": "^0.8.1",
-    "@kubun/plugin-connector": "^0.8.2",
-    "@kubun/plugin-http": "^0.8.1",
-    "@kubun/plugin-rpc": "^0.8.1",
-    "@kubun/test-utils": "^0.8.0"
+    "@kubun/db-better-sqlite": "^0.10.0",
+    "@kubun/plugin-connector": "^0.10.0",
+    "@kubun/hub": "^0.10.0",
+    "@kubun/db-node-sqlite": "^0.10.0",
+    "@kubun/plugin-http": "^0.10.0",
+    "@kubun/plugin-rpc": "^0.10.0",
+    "@kubun/test-utils": "^0.10.0"
   },
   "scripts": {
     "build:clean": "del lib",