h1v3 0.4.1 → 0.6.0

package/dist/browser/client/team/invites.js

@@ -0,0 +1,119 @@
+const ADDED_TO_TEAM = "ADDED_TO_TEAM";
+const ACCEPTED_INVITATION = "ACCEPTED_INVITATION";
+const REJECTED_INVITATION = "REJECTED_INVITATION";
+const INVITE_ACCEPTED = "INVITE_ACCEPTED";
+const INVITE_REJECTED = "INVITE_REJECTED";
+
+export function userInvites({ email, uid, teamMembershipStoreFactory, userTeamsStore, userInvitesStore, handleErrors = console.error.bind(console) }) {
+
+    if (!email) throw new Error("Missing email");
+    if (!uid) throw new Error("Missing uid");
+    if (!teamMembershipStoreFactory) throw new Error("Missing teamMembershipStoreFactory");
+    if (!userInvitesStore) throw new Error("Missing userInvitesStore");
+    if (!userTeamsStore) throw new Error("Missing userTeamsStore");
+
+    let unsubscribe = userInvitesStore.onProjectionValue("pending", handleUserInvitesUpdated);
+    let lastUserInvites;
+    const onInvitesCallbacks = [];
+
+    return {
+
+        async getInvites() {
+
+            return userInvitesStore.getProjection("pending");
+
+        },
+
+        async rejectInvite({ id, name = "" }) {
+
+            try {
+
+                await respondToInvite({ id, name, invitesEvent: REJECTED_INVITATION, teamMembershipEvent: INVITE_REJECTED });
+
+            } catch(err) {
+
+                handleErrors(err);
+
+            }
+
+        },
+
+        async acceptInvite({ id, name = "" }) {
+
+            try {
+
+                const { tid } = await respondToInvite({ id, name, invitesEvent: ACCEPTED_INVITATION, teamMembershipEvent: INVITE_ACCEPTED });
+                await userTeamsStore.record(ADDED_TO_TEAM, { id, tid });
+
+            } catch(err) {
+
+                handleErrors(err);
+
+            }
+
+        },
+
+        onInvites(callback) {
+
+            onInvitesCallbacks.push(callback);
+            callback(lastUserInvites);
+
+        },
+
+        offInvites(callback) {
+
+            while(onInvitesCallbacks.includes(callback)) {
+
+                onInvitesCallbacks.splice(onInvitesCallbacks.indexOf(callback), 1);
+
+            }
+
+        },
+
+        dispose() {
+
+            if (!unsubscribe) return;
+            unsubscribe();
+            unsubscribe = null;
+
+        }
+
+    };
+
+    function handleUserInvitesUpdated(snap) {
+
+        lastUserInvites = snap.val();
+        dispatchInvitesCallbacks();
+
+    }
+
+    function dispatchInvitesCallbacks() {
+
+        onInvitesCallbacks.forEach(x => x(lastUserInvites));
+
+    }
+
+    async function respondToInvite({ id, name, invitesEvent, teamMembershipEvent }) {
+
+        const invitations = await userInvitesStore.getProjection("pending");
+        const invite = invitations.invites?.[id];
+        if (!invite) throw new Error("Invitation not found");
+
+        const { tid } = invite;
+        if (!tid) throw new Error("Event info invalid: missing tid");
+
+        const teamMembershipStore = teamMembershipStoreFactory({ tid });
+
+        // record acceptance/rejection in the user invites store - only if my email matches the accepted invite
+        await userInvitesStore.record(invitesEvent, { id });
+
+        // record acceptance in the team membership store - only if email matches inviteUser's email and uid matches me
+        await teamMembershipStore.record(teamMembershipEvent, { id, email, uid, name });
+
+        return { tid };
+
+    }
+
+}
+
+

package/dist/browser/client/team/team.js

@@ -0,0 +1,143 @@
+export const BECAME_MEMBER = "BECAME_MEMBER";
+export const BECAME_ADMIN = "BECAME_ADMIN";
+export const ADDED_TO_TEAM = "ADDED_TO_TEAM";
+export const MEMBER_INVITED = "MEMBER_INVITED";
+export const ADMIN_INVITED = "ADMIN_INVITED";
+export const DETAILS_UPDATED = "DETAILS_UPDATED";
+
+const notSupportedFactory = strategy => () => {
+
+    throw new Error(`Not supported ${strategy}`);
+
+};
+
+function bufferedSubscription(store, projectionName, handleError) {
+
+    store.onProjectionValue(projectionName, onChange, handleError);
+
+    const callbacks = [];
+    let lastProjectionValue;
+
+    function onChange(snap) {
+
+        lastProjectionValue = snap.val();
+        for(const callback of callbacks)
+            callback(lastProjectionValue);
+
+    }
+
+    return {
+
+        onChange(callback) {
+
+            callbacks.push(callback);
+            if(lastProjectionValue) callback(lastProjectionValue);
+
+        },
+
+        offChange(callback) {
+
+            while(callbacks.includes(callback)) {
+
+                callbacks.splice(callbacks.indexOf(callback), 1);
+
+            }
+
+        }
+
+    };
+
+}
+
+export function team({
+    teamMembershipStore,
+    userInvitesStoreFactory,
+    teamDetailsStore,
+    userTeamsStoreFactory = notSupportedFactory("Build user teams event store"),
+    handleError = console.error.bind(console)
+}) {
+
+    if (!teamMembershipStore) throw new Error(`Missing teamMembershipStore`);
+    if (!teamDetailsStore) throw new Error(`Missing teamDetailsStore`);
+    if (!userInvitesStoreFactory) throw new Error(`Missing userInvitesStoreFactory`);
+
+    const teamPathPattern = /\/teams\/([^\/]*)/g.exec(teamMembershipStore?.path);
+    if (!teamPathPattern?.[1]) throw new Error(`Invalid team path: ${teamMembershipStore?.path}`);
+    const tid = teamPathPattern[1];
+
+    const { onChange: onMembershipDetails, offChange: offMembershipDetails } = bufferedSubscription(teamMembershipStore, "details", handleError);
+    const { onChange: onDetails, offChange: offDetails } = bufferedSubscription(teamDetailsStore, "current", handleError);
+
+    return {
+
+        async addAdmin({ uid, name, ...rest }) {
+
+            await recordMembership({ uid, name, eventType: BECAME_ADMIN, rest });
+
+        },
+
+        async addMember({ uid, name, ...rest }) {
+
+            await recordMembership({ uid, name, eventType: BECAME_MEMBER, rest });
+
+        },
+
+        onMembershipDetails,
+
+        offMembershipDetails,
+
+        onDetails,
+
+        offDetails,
+
+        async inviteMember({ email, name, createdBy }) {
+
+            if (!email) throw new Error("Missing email");
+            if (!createdBy) throw new Error("Missing createdBy");
+            await recordInvitation({ eventType: MEMBER_INVITED, email, name, createdBy, role: "Member" });
+
+        },
+
+        async inviteAdmin({ email, name, createdBy }) {
+
+            if (!email) throw new Error("Missing email");
+            if (!createdBy) throw new Error("Missing createdBy");
+            await recordInvitation({ eventType: ADMIN_INVITED, email, name, createdBy, role: "Administrator" });
+
+        },
+
+        async setDetails(details) {
+
+            await teamDetailsStore.record(DETAILS_UPDATED, details);
+
+        }
+
+    };
+
+    async function recordMembership({ uid, name, eventType, rest }) {
+
+        if (!uid) throw new Error("Missing uid");
+        if (!name) throw new Error("Missing name");
+        await teamMembershipStore.record(eventType, { uid, name, ...rest });
+        const userTeamsStore = userTeamsStoreFactory({ uid });
+        await userTeamsStore.record(ADDED_TO_TEAM, { tid });
+
+    }
+
+    async function recordInvitation({ eventType, email, name, createdBy, role }) {
+
+        if (!email) throw new Error("Missing email");
+        if (!createdBy) throw new Error("Missing createdBy");
+        if (!name) throw new Error("Missing name");
+        if (!role) throw new Error("Missing role");
+
+        const id = crypto.randomUUID().replaceAll("-", "");
+
+        const team = await teamDetailsStore.getProjection("current");
+        await teamMembershipStore.record(eventType, { email, name, createdBy, id });
+        const userInvitesStore = userInvitesStoreFactory({ emailId: btoa(email) });
+        await userInvitesStore.record("INVITED_TO_TEAM", { email, name, tid, role, team, id });
+
+    }
+
+}

package/dist/browser/client/team/user.js

@@ -0,0 +1,62 @@
+export const DETAILS_UPDATED = "DETAILS_UPDATED";
+
+export function user({ userTeamsStore, userProfileStore }) {
+
+    if (!userTeamsStore) throw new Error("Missing userTeamsStore");
+    if (!userProfileStore) throw new Error("Missing userProfileStore");
+
+    userTeamsStore.onProjectionValue("current", handleTeamsCurrentChanged);
+
+    const onTeamsCallback = [];
+    let lastProjectionValue;
+
+    return {
+
+        async setDetails(details) {
+
+            await userProfileStore.record(DETAILS_UPDATED, details);
+
+        },
+
+        onTeams(callback) {
+
+            onTeamsCallback.push(callback);
+            if(lastProjectionValue) callback(lastProjectionValue);
+
+        },
+
+        offTeams(callback) {
+
+            while(onTeamsCallback.includes(callback)) {
+
+                onTeamsCallback.splice(onTeamsCallback.indexOf(callback), 1);
+
+            }
+
+        }
+
+    }
+
+    async function handleTeamsCurrentChanged(snap) {
+
+        lastProjectionValue = await enumerateTeams(snap);
+        for(const callback of onTeamsCallback)
+            callback(lastProjectionValue);
+
+    }
+
+
+    async function enumerateTeams(myTeamsSnap) {
+
+        const val = myTeamsSnap.val();
+        const teams = val?.teams;
+        if (!teams) return null;
+        return Object.entries(teams).map(([key, val]) => ({
+            id: key,
+            name: key,
+            since: new Date(val)
+        }));
+
+    }
+
+}

package/package.json

@@ -1,23 +1,18 @@
 {
   "name": "h1v3",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "",
   "license": "MIT",
   "author": "",
   "type": "module",
   "exports": {
     ".": "./src/index.js",
-    "./schema": "./src/schema.js",
-    "./client": "./src/client/index.js",
-    "./membership": "./src/membership/index.js"
+    "./client": "./src/client/index.js"
   },
   "bin": {
     "eventstore": "./src/exec-eventstore.js"
   },
   "dependencies": {
     "minimist": "^1.2.8"
-  },
-  "scripts": {
-    "dist:client": "node ./scripts/dist-client.js"
   }
 }

package/src/client/context.js

@@ -0,0 +1,58 @@
+import { eventStoreFromConfig as defaultEventStoreFromConfig } from "./node.js";
+import { team } from "../../dist/browser/client/team/team.js";
+import { user } from "../../dist/browser/client/team/user.js";
+
+export function inject({
+    db,
+    teamMembershipConfig,
+    userTeamsConfig,
+    userInvitesConfig,
+    teamDetailsConfig,
+    userProfileConfig,
+    eventStoreFromConfig = defaultEventStoreFromConfig
+}) {
+
+    if (!teamMembershipConfig) throw new Error("Missing: teamMembershipConfig");
+    if (!userInvitesConfig) throw new Error("Missing: userInvitesConfig");
+    if (!teamDetailsConfig) throw new Error("Missing: teamDetailsConfig");
+    if (!userProfileConfig) throw new Error("Missing: userProfileConfig");
+    if (!db) throw new Error("Missing: db");
+
+    return {
+
+        team({ tid }) {
+
+            const teamMembershipStore = eventStoreFromConfig(db, teamMembershipConfig, { tid });
+            const teamDetailsStore = eventStoreFromConfig(db, teamDetailsConfig, { tid });
+            return team({
+                teamMembershipStore,
+                teamDetailsStore,
+                userInvitesStoreFactory,
+                userTeamsStoreFactory,
+            });
+
+        },
+
+        userProfile({ uid }) {
+
+            const userTeamsStore = eventStoreFromConfig(db, userTeamsConfig, { uid });
+            const userProfileStore = eventStoreFromConfig(db, userProfileConfig, { uid });
+            return user({ userTeamsStore, userProfileStore });
+
+        }
+
+    };
+
+    function userTeamsStoreFactory({ uid }) {
+
+        return eventStoreFromConfig(db, userTeamsConfig, { uid });
+
+    }
+
+    function userInvitesStoreFactory({ emailId }) {
+
+        return eventStoreFromConfig(db, userInvitesConfig, { emailId });
+
+    }
+
+}

package/src/client/index.js

@@ -1,4 +1,2 @@
-export * as node from "./node.js";
-export * as modular from "./modular.js";
-export * as teamNode from "./team-node.js";
-export * as team from "./team.js";
+export * from "./node.js";
+export * from "./context.js";

package/src/client/node.js

@@ -1,5 +1,5 @@
-import { EVENT_STORE_META } from "../event-store/initialise.js";
-import { eventStore as eventStoreModular } from "./modular.js";
+import { EVENT_STORE_META } from "../event-store/configuration.js";
+import { eventStore as eventStoreModular } from "../../dist/browser/client/event-store.js";
 
 function adapter(db) {
 

package/src/commands/generate-rules.js

@@ -1,32 +1,56 @@
-function eventWriteConditions(config) {
+import { EVENTS, PROJECTIONS } from "../../dist/browser/client/event-store.js";
+import { explodePathVars } from "../index.js";
 
-    if (config?.write === false)
-        return false;
-    let expr = "!data.exists()"
+function writeConditions(config) {
+
+    if (config.write === false) return false;
+    let expr = "auth.uid != null && !data.exists()";
     if (config?.write)
-        expr += " && (" + config.write + ")"
+        expr += " && (" + explodePathVars(config.write) + ")"
     return expr;
 
 }
 
-function projectionReadConditions(config) {
+function readConditions(config) {
 
-    return config.read || true;
+    return config.read === false
+        ? false
+        : config.read
+            ? explodePathVars(config.read)
+            : true;
 
 }
 
+function eventValidation(config) {
+
+    const requireType = "newData.child('type').isString()";
+    if (!Array.isArray(config?.eventTypes)) return requireType;
+    return [
+        requireType,
+        `newData.child('type').val().matches(/^(${config.eventTypes.join("|")})$/)`
+    ].join(" && ");
+
+}
+
+const rawRules = config => ({
+    ".read": readConditions(config),
+    ".write": writeConditions(config)
+});
+
 const eventStoreRules = config => ({
     ".read": false,
     ".write": false,
-    events: {
-        "$eid": {
-            ".write": eventWriteConditions(config),
-            ".validate": eventValidation(config)
-        }
+    [EVENTS]: {
+        "$eid": config?.write === false
+            ? { ".write": false }
+            : {
+                ".write": writeConditions(config),
+                ".validate": eventValidation(config)
+            }
     },
-    projections: {
+    [PROJECTIONS]: {
         "$pid": {
-            ".read": projectionReadConditions(config)
+            ".read": readConditions(config)
         }
     }
 });
@@ -36,6 +60,11 @@ const splitPathIntoSegments = path =>
         .split("/")
         .filter(x => x);
 
+const rules = config =>
+    config.raw
+        ? rawRules(config)
+        : eventStoreRules(config);
+
 const addRulesForPath = (existingRules, [
     [
         nextSegment,
@@ -55,7 +84,7 @@ const addRulesForPath = (existingRules, [
             )
         }
         // stick the rules here
-        : eventStoreRules(config);
+        : rules(config);
 
 const parseConfig = ([_name, config]) => [
     // 0: the path
@@ -64,30 +93,18 @@ const parseConfig = ([_name, config]) => [
     config
 ];
 
-function eventValidation(config) {
-
-    const requireType = "newData.child('type').isString()";
-    if (!Array.isArray(config?.eventTypes)) return requireType;
-    return [
-        requireType,
-        `newData.child('type').val().matches(/^(${config.eventTypes.join("|")})$/)`
-    ].join(" && ");
-
-}
-
-export function generateRules(argv, stores) {
-
-    const json = JSON.stringify(
-        stores
-            // parse the path
-            .map(parseConfig)
-            // build the map
-            .reduce(addRulesForPath, {}),
-        null, 4);
-    if(argv.snippet)
-        console.log(json.slice(1,-1));
-    else
-        console.log(json);
+export function generateRules(_argv, eventStores, rawStores) {
+
+    console.log(
+        JSON.stringify(
+        {
+            rules: [
+                ...eventStores.map(parseConfig),
+                ...rawStores.map(parseConfig)
+            ].reduce(addRulesForPath, {})
+        },
+        null, 4)
+    );
 
 }