nervur 0.7.0 → 0.7.2

package/admin.mjs

@@ -4,7 +4,8 @@ const ADMIN = `({
   memory: { 'aliases/*': { type: 'String', class: 'data' } },
   interface: \`
     input RefInput { address: String!, nextPkHash: String, rights: String }
-    type Census { stored: Int!, active: Int! }
+    type Resident { address: String!, alias: String, digest: String, active: Boolean! }
+    type Census { residents: [Resident!]!, stored: Int!, active: Int! }
     type Query {
       census: Census                   @rights(is: [SELF, MEMBER])
       aliasOf(name: String!): String   @rights(is: [SELF, MEMBER])
@@ -23,10 +24,14 @@ const ADMIN = `({
   \`,
   resolvers: {
     Query: {
-      census: (_, __, { registry }) => ({
-        active: registry.active(),
-        stored: registry.stored(),
-      }),
+      census: (_, __, { registry }) => {
+        const residents = registry.residents();
+        return {
+          active: residents.filter((one) => one.active).length,
+          residents,
+          stored: residents.length,
+        };
+      },
       aliasOf: (_, { name }, { modules }) => modules.memory.read('aliases/' + name),
       attest: (_, { module }, { registry }) => registry.attest(module),
       opened: (_, __, { modules }) => modules.memory.list('refs/').length > 0,

package/being.mjs

@@ -169,6 +169,9 @@ const Being = ({ voice, address, modules, registry, vouched, watch }) => {
         }
         const rights = self ? 'SELF' : (row?.rights ?? 'STRANGER');
         if (op?.describe !== undefined) {
+          if (program !== undefined && !program.visible(rights)) {
+            return undefined;
+          }
           return answer({
             address,
             digest: program?.digest,
@@ -254,6 +257,7 @@ const make = ({ memory, voice, address, program }) => {
 const Registry = ({
   memory,
   adminMine,
+  address,
   modules,
   modulesFor,
   announce,
@@ -263,22 +267,21 @@ const Registry = ({
   watch,
 }) => {
   const live = new Map();
-  const activate = (address) => {
-    if (live.has(address)) {
-      return live.get(address);
+  const activate = (at) => {
+    if (live.has(at)) {
+      return live.get(at);
     }
-    const held = adminMine.read(`identity/custody/${address}`);
+    const held = adminMine.read(`identity/custody/${at}`);
     const voice = held === undefined ? undefined : Voice.revive(held);
     if (voice === undefined) {
       return undefined;
     }
-    const door = Being({ voice, address, modules: modulesFor(voice), vouched, watch });
-    live.set(address, door);
+    const door = Being({ voice, address: at, modules: modulesFor(voice), vouched, watch });
+    live.set(at, door);
     return door;
   };
   return Object.freeze({
     activate,
-    active: () => live.size,
     attest,
     create: ({ program, refs = [], data = {}, bindings, config } = {}) => {
       const written = program === undefined ? undefined : Program(program);
@@ -326,43 +329,67 @@ const Registry = ({
       announce(address);
       return address;
     },
-    deactivate: (address) => live.delete(address),
-    upgrade: ({ address, program }) => {
-      const held = adminMine.read(`identity/custody/${address}`);
-      const voice = held === undefined ? undefined : Voice.revive(held);
+    deactivate: (at) => live.delete(at),
+    upgrade: ({ address: target, program }) => {
       const written = program === undefined ? undefined : Program(program);
-      if (voice === undefined || written === undefined) {
+      if (written === undefined) {
         return undefined;
       }
       const orphaned = memory
-        .list(address, '')
-        .filter((key) => memory.read(address, key)?.value !== null)
+        .list(target, '')
+        .filter((key) => memory.read(target, key)?.value !== null)
         .filter((key) => written.classOf(key) === undefined);
       if (orphaned.length > 0) {
         return undefined;
       }
+      if (target === address) {
+        return adminMine.write('program', program) === undefined ? undefined : target;
+      }
+      const held = adminMine.read(`identity/custody/${target}`);
+      const voice = held === undefined ? undefined : Voice.revive(held);
+      if (voice === undefined) {
+        return undefined;
+      }
       const claim = {
-        address,
+        address: target,
         key: 'program',
         value: program,
-        version: (memory.read(address, 'program')?.version ?? 0) + 1,
+        version: (memory.read(target, 'program')?.version ?? 0) + 1,
       };
       if (memory.write({ ...claim, sig: voice.sign(Tools.canon(claim)) }) === undefined) {
         return undefined;
       }
-      live.delete(address);
-      return address;
+      live.delete(target);
+      return target;
     },
-    destroy: (address) => {
-      if (adminMine.read(`identity/custody/${address}`) === undefined) {
+    destroy: (at) => {
+      if (adminMine.read(`identity/custody/${at}`) === undefined) {
         return undefined;
       }
-      adminMine.write(`identity/custody/${address}`, undefined);
-      live.delete(address);
-      forget(address);
-      return address;
+      adminMine.write(`identity/custody/${at}`, undefined);
+      live.delete(at);
+      forget(at);
+      return at;
+    },
+    residents: () => {
+      const aliasFor = new Map();
+      for (const key of adminMine.list('aliases/')) {
+        const named = adminMine.read(key);
+        if (typeof named === 'string') {
+          aliasFor.set(named, key.slice('aliases/'.length));
+        }
+      }
+      return adminMine.list('identity/custody/').map((key) => {
+        const at = key.slice('identity/custody/'.length);
+        const digest = Program(memory.read(at, 'program')?.value)?.digest ?? null;
+        return {
+          address: at,
+          alias: aliasFor.get(at) ?? null,
+          active: live.has(at),
+          digest,
+        };
+      });
     },
-    stored: () => adminMine.list('identity/custody/').length,
   });
 };
 

package/ground.mjs

@@ -147,6 +147,7 @@ const Ground = (modules = {}) => {
   const registry = Registry({
     memory,
     adminMine,
+    address,
     modules: adminModules,
     modulesFor,
     announce,
@@ -155,14 +156,11 @@ const Ground = (modules = {}) => {
     attest,
     watch,
   });
-  const admin = Being({
-    voice: adminVoice,
-    address,
-    modules: adminModules,
-    registry,
-    vouched,
-    watch,
-  });
+  const admin = (envelope, token) =>
+    Being({ voice: adminVoice, address, modules: adminModules, registry, vouched, watch })(
+      envelope,
+      token,
+    );
 
   announce(address);
   for (const key of adminMine.list('identity/custody/')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "A distributed system of sovereign beings — one door, one question: by whose authority.",
   "license": "Apache-2.0",
   "author": "Razvan Gherghina",

package/program.mjs

@@ -68,6 +68,16 @@ const Program = (source) => {
     name: blueprint.name,
     rights: blueprint.rights,
     sdlFor: blueprint.sdlFor,
+    visible: (held) => {
+      const filtered = seenBy(held);
+      if (filtered === undefined) {
+        return false;
+      }
+      const rooted = [filtered.getQueryType(), filtered.getMutationType()].filter(
+        (one) => one !== undefined && one !== null,
+      );
+      return rooted.some((one) => Object.keys(one.getFields()).length > 0);
+    },
   });
 };