@kubun/plugin-p2p 0.10.0 → 0.11.0

package/lib/context/delegation.js

@@ -1 +1,130 @@
-import{getGraphStore as e}from"@kubun/store-graph";import{getP2PStore as t}from"@kubun/store-p2p";import{GraphQLError as r}from"graphql";export function createDelegationContext(r,u){let a=null,i=null,d=()=>a??=t(u.stores),c=()=>i??=e(u.stores);return{listOwnTokens:async({viewerDID:e,grantor:t,covers:r})=>{let n=await d(),u=Math.floor(Date.now()/1e3),a=await n.getHeldTokens({audience:e,atTime:u}),i=null!=t?a.filter(e=>e.grantor===t):a,s=i;return null!=r&&(null!=r.docID||null!=r.modelID)&&(s=await o(i,r,c)),s.map(l)},listOwnRevokedTokens:async({viewerDID:e,grantor:t})=>{let r=await d(),o=await r.getHeldRevocations({audience:e});return(null!=t?o.filter(e=>e.grantor===t):o).map(n)}}}function n(e){return{jti:e.jti,grantor:e.grantor,audience:e.audience,revokerDID:e.revoker_did,revokedAt:e.revoked_iat,verifiedAt:e.verified_at,capExp:e.cap_exp,groupID:e.group_id}}async function o(e,t,n){let o=null,l=null;if(null!=t.docID){l=t.docID;let e=await n(),u=null;try{u=await e.getDocument(t.docID)}catch{return[]}if(null==u)return[];if(o=u.model,null!=t.modelID&&t.modelID!==o)throw new r(`Document ${l} has model ${o}, not ${t.modelID}`,{extensions:{code:"DELEGATION_TOKEN_COVERS_MISMATCH"}})}else null!=t.modelID&&(o=t.modelID);if(null==o)return e;let u=new Map,a=await n(),i=u.get(o);null==i&&(i=await a.getModelInterfaces(o),u.set(o,i));let d=new Set;for(let e of(d.add(`urn:kubun:model:${o}`),i))d.add(`urn:kubun:model:${e}`);let c=null!=l?`urn:kubun:document:${l}`:null;return e.filter(e=>!!("*"===e.resource||e.resource===`urn:kubun:user:${e.grantor}`||d.has(e.resource))||null!=c&&e.resource===c)}function l(e){return{jwt:e.token,jti:e.jti,grantor:e.grantor,audience:e.audience,resource:e.resource,exp:e.exp}}
+import { getDelegationStore as resolveDelegationStore } from '@kubun/store-delegation';
+import { getGraphStore as resolveGraphStore } from '@kubun/store-graph';
+import { getP2PStore as resolveP2PStore } from '@kubun/store-p2p';
+import { GraphQLError } from 'graphql';
+export function createDelegationContext(_ctx, deps) {
+    let p2pStorePromise = null;
+    let delegationStorePromise = null;
+    let graphStorePromise = null;
+    const getP2PStore = ()=>p2pStorePromise ??= resolveP2PStore(deps.stores);
+    const getDelegationStore = ()=>delegationStorePromise ??= resolveDelegationStore(deps.stores);
+    const getGraphStore = ()=>graphStorePromise ??= resolveGraphStore(deps.stores);
+    return {
+        listOwnTokens: async ({ viewerDID, grantor, covers })=>{
+            const delegationStore = await getDelegationStore();
+            const atTime = Math.floor(Date.now() / 1000);
+            const rows = await delegationStore.getHeldTokens({
+                audience: viewerDID,
+                atTime
+            });
+            const filteredByGrantor = grantor != null ? rows.filter((row)=>row.grantor === grantor) : rows;
+            let coverageFiltered = filteredByGrantor;
+            if (covers != null && (covers.docID != null || covers.modelID != null)) {
+                coverageFiltered = await applyCoverageFilter(filteredByGrantor, covers, getGraphStore);
+            }
+            return coverageFiltered.map(rowToData);
+        },
+        listOwnRevokedTokens: async ({ viewerDID, grantor })=>{
+            const [delegationStore, p2pStore] = await Promise.all([
+                getDelegationStore(),
+                getP2PStore()
+            ]);
+            const rows = await delegationStore.getHeldRevocations({
+                audience: viewerDID
+            });
+            const filtered = grantor != null ? rows.filter((row)=>row.grantor === grantor) : rows;
+            // The core revocation row carries no group; enrich each with the group the
+            // cap was granted in via the p2p `jti` edge. A held revocation always has
+            // a locally-held cap, and every locally-stored cap wrote an edge at grant
+            // time, so the lookup resolves; a row with no edge is dropped rather than
+            // reported with an unknown group.
+            const jtis = filtered.map((row)=>row.jti);
+            const groupByJTI = await p2pStore.getGroupIDsByJTIs(jtis);
+            const enriched = filtered.map((row)=>{
+                const groupID = groupByJTI.get(row.jti);
+                return groupID != null ? revocationRowToData(row, groupID) : null;
+            });
+            return enriched.filter((data)=>data != null);
+        }
+    };
+}
+function revocationRowToData(row, groupID) {
+    return {
+        jti: row.jti,
+        grantor: row.grantor,
+        audience: row.audience,
+        revokerDID: row.revoker_did,
+        revokedAt: row.revoked_iat,
+        verifiedAt: row.verified_at,
+        capExp: row.cap_exp,
+        groupID
+    };
+}
+async function applyCoverageFilter(rows, covers, getGraphStore) {
+    // Resolve concrete model. When `docID` is supplied it wins (its derived model
+    // is authoritative); when both are supplied, the doc's model must match the
+    // hint or the caller's intent is ambiguous — reject with an explicit error.
+    let modelID = null;
+    let docID = null;
+    if (covers.docID != null) {
+        docID = covers.docID;
+        const graphStore = await getGraphStore();
+        // A malformed docID — one the document store cannot parse — is treated the
+        // same as a doc that does not exist locally: no token can cover it, so
+        // the result is empty.
+        let doc = null;
+        try {
+            doc = await graphStore.getDocument(covers.docID);
+        } catch  {
+            return [];
+        }
+        if (doc == null) {
+            return [];
+        }
+        modelID = doc.model;
+        if (covers.modelID != null && covers.modelID !== modelID) {
+            throw new GraphQLError(`Document ${docID} has model ${modelID}, not ${covers.modelID}`, {
+                extensions: {
+                    code: 'DELEGATION_TOKEN_COVERS_MISMATCH'
+                }
+            });
+        }
+    } else if (covers.modelID != null) {
+        modelID = covers.modelID;
+    }
+    if (modelID == null) {
+        return rows;
+    }
+    // Per-call interface cache. Single model in this resolver call, but the
+    // cache keeps the shape consistent if the API grows multi-model later.
+    const interfaceCache = new Map();
+    const graphStore = await getGraphStore();
+    let interfaceIDs = interfaceCache.get(modelID);
+    if (interfaceIDs == null) {
+        interfaceIDs = await graphStore.getModelInterfaces(modelID);
+        interfaceCache.set(modelID, interfaceIDs);
+    }
+    const modelResources = new Set();
+    modelResources.add(`urn:kubun:model:${modelID}`);
+    for (const id of interfaceIDs){
+        modelResources.add(`urn:kubun:model:${id}`);
+    }
+    const docResource = docID != null ? `urn:kubun:document:${docID}` : null;
+    return rows.filter((row)=>{
+        if (row.resource === '*') return true;
+        if (row.resource === `urn:kubun:user:${row.grantor}`) return true;
+        if (modelResources.has(row.resource)) return true;
+        if (docResource != null && row.resource === docResource) return true;
+        return false;
+    });
+}
+function rowToData(row) {
+    return {
+        jwt: row.token,
+        jti: row.jti,
+        grantor: row.grantor,
+        audience: row.audience,
+        resource: row.resource,
+        exp: row.exp
+    };
+}