h1v3 0.3.0 → 0.6.0

package/src/membership/team-membership/projections/details.js

@@ -0,0 +1,105 @@
+import { purgeUser, resolveUserView, purgeInvited, resolveInvitationView, recordInviteInContext } from "./_shared.js";
+import { BECAME_MEMBER, BECAME_ADMIN, LEFT_TEAM, MEMBER_INVITED, ADMIN_INVITED, INVITE_ACCEPTED } from "../events.js";
+
+export default {
+
+    [BECAME_MEMBER]: (view, { meta, payload }) => {
+
+        if (!payload.uid) return view;
+        return ({
+            ...view,
+            members: { ...view.members, [payload.uid]: resolveUser(view, payload, null, meta) }
+        });
+    }
+    ,
+
+    [BECAME_ADMIN]: (view, { meta, payload }) => {
+
+        if (!payload.uid) return view;
+        return ({
+            ...view,
+            admins: { ...view.admins, [payload.uid]: resolveUser(view, payload, null, meta) }
+        });
+
+    },
+
+    [INVITE_ACCEPTED]: (view, { meta, payload }, context) => {
+
+        if (!payload?.id) return view;
+        if (!payload.uid) return view;
+        if (!context.invites) return view;
+        const record = context.invites[payload.id];
+        if (!record) return view;
+        switch (record.type) {
+
+            case MEMBER_INVITED:
+                view.members = { ...view.members, [payload.uid]: resolveUser(view, payload, record, meta) };
+                break;
+
+            case ADMIN_INVITED:
+                view.admins = { ...view.admins, [payload.uid]: resolveUser(view, payload, record, meta) };
+                break;
+
+            default:
+                return view;
+
+        }
+        if (view.invitedMembers) {
+
+            view.invitedMembers = Object.fromEntries(Object.entries(view.invitedMembers).filter(([key, invite]) => invite.id !== payload.id));
+
+        }
+        if (view.invitedAdmins) {
+
+            view.invitedAdmins = Object.fromEntries(Object.entries(view.invitedAdmins).filter(([key, invite]) => invite.id !== payload.id));
+
+        }
+        delete context.invites[payload.id];
+        return view;
+
+    },
+
+    [LEFT_TEAM]: (view, { payload }) => {
+
+        purgeUser(view, payload);
+        return view;
+
+    },
+
+    [MEMBER_INVITED]: (view, { meta, payload }, context) => {
+
+        if (!payload?.email) return view;
+        if (!payload?.createdBy) return view;
+        if (!payload.id) return view;
+        const key = btoa(payload.email.toLowerCase());
+        purgeInvited(view, key);
+        view.invitedMembers = { ...view.invitedMembers, [key]: resolveInvitationView(payload, meta) };
+        recordInviteInContext(context, payload.id, { type: MEMBER_INVITED, payload });
+        return view;
+
+    },
+
+    [ADMIN_INVITED]: (view, { meta, payload }, context) => {
+
+        if (!payload?.email) return view;
+        if (!payload.createdBy) return view;
+        if (!payload.id) return view;
+        const key = btoa(payload.email.toLowerCase());
+        purgeInvited(view, key);
+        view.invitedAdmins = { ...view.invitedAdmins, [key]: resolveInvitationView(payload, meta) };
+        recordInviteInContext(context, payload.id, { type: ADMIN_INVITED, payload });
+        return view;
+
+    },
+
+};
+
+function resolveUser(view, { uid, name, email, createdBy }, maybeInvite, meta) {
+
+    const found = purgeUser(view, { uid });
+    name = name || maybeInvite?.payload?.name;
+    return resolveUserView({ name, email, createdBy }, found, meta);
+
+}
+
+

package/src/membership/team-membership/projections/inviteToEmail.js

@@ -0,0 +1,25 @@
+import { ADMIN_INVITED, INVITE_ACCEPTED, INVITE_REJECTED, MEMBER_INVITED } from "../events.js";
+import { passThrough } from "./_shared.js";
+
+function addToMap(view, { payload }) {
+
+    if (!(payload?.id && payload.email)) return view;
+    return Object.assign({}, view, { [payload.id]: payload.email });
+
+}
+
+function removeFromMap(view, { payload }) {
+
+    if (!payload.id) return view;
+    delete view[payload.id];
+    return view;
+
+}
+
+export default {
+    [MEMBER_INVITED]: addToMap,
+    [ADMIN_INVITED]: addToMap,
+    [INVITE_ACCEPTED]: removeFromMap,
+    [INVITE_REJECTED]: removeFromMap,
+    ["?"]: passThrough
+}

package/src/membership/team-membership/projections/members.js

@@ -0,0 +1,68 @@
+import { BECAME_MEMBER, BECAME_ADMIN, LEFT_TEAM, MEMBER_INVITED, ADMIN_INVITED, INVITE_ACCEPTED } from "../events.js";
+import { recordInviteInContext } from "./_shared.js";
+
+export default {
+
+    [BECAME_MEMBER]: (view, { payload }) => {
+
+        if (!payload?.uid) return view;
+        view[payload.uid] = true;
+        return view;
+
+    },
+
+    [BECAME_ADMIN]: (view, { payload }) => {
+
+        if (!payload?.uid) return view;
+        view[payload.uid] = true;
+        return view;
+
+    },
+
+    [INVITE_ACCEPTED]: (view, { payload }, context) => {
+
+        if (!payload?.id) return view;
+        if (!payload.uid) return view;
+        if (!context.invites) return view;
+        const record = context.invites[payload.id];
+        if (!record) return view;
+        switch (record.type) {
+
+            case MEMBER_INVITED:
+                view[payload.uid] = true;
+                delete context.invites[payload.id];
+                break;
+
+            case ADMIN_INVITED:
+                view[payload.uid] = true;
+                delete context.invites[payload.id];
+                break;
+
+        }
+        return view;
+
+    },
+
+    [LEFT_TEAM]: (view, { payload }) => {
+
+        if (!payload?.uid) return view;
+        delete view[payload.uid];
+        return view;
+
+    },
+
+    [MEMBER_INVITED]: (view, { payload }, context) => {
+
+        recordInviteInContext(context, payload.id, { type: MEMBER_INVITED, payload });
+        return view;
+
+    },
+
+    [ADMIN_INVITED]: (view, { payload }, context) => {
+
+        recordInviteInContext(context, payload.id, { type: ADMIN_INVITED, payload });
+        return view;
+
+    },
+
+};

package/src/membership/team-membership/store.js

@@ -0,0 +1,56 @@
+import details from "./projections/details.js";
+import members from "./projections/members.js";
+import inviteToEmail from "./projections/inviteToEmail.js";
+
+import { eventTypes, INVITE_ACCEPTED, INVITE_REJECTED } from "./events.js";
+import {
+    newDataPayloadId,
+    assertPayloadUidMyUserId,
+    assertMyRoleIsAdmin,
+    assertIsMyTeam,
+    assertMyEmailVerified,
+    teamInviteToEmailMapping,
+    any,
+    all,
+    assertEventIsOfType
+} from "../../rules.js";
+import { verifyStorePaths } from "../team-details/verify-store-paths.js";
+
+export function store(paths) {
+
+    verifyStorePaths(paths, {
+        team: {
+            membership: { path: String }
+        }
+    });
+    return {
+        ref: paths.team.membership.path,
+        projections: {
+            details,
+            members,
+            inviteToEmail
+        },
+        write: any(
+
+            assertMyRoleIsAdmin(paths),
+            all(
+
+                assertEventIsOfType(INVITE_ACCEPTED, INVITE_REJECTED),
+                all(
+
+                    `${teamInviteToEmailMapping(paths)}.child(${newDataPayloadId}).val() === auth.email`,
+                    assertMyEmailVerified,
+                    assertPayloadUidMyUserId
+
+                )
+
+            )
+
+        ),
+        read: assertIsMyTeam(paths),
+        eventTypes
+    };
+
+}
+
+export * from "./events.js";

package/src/membership/user-profile/events.js

@@ -0,0 +1,6 @@
+
+export const DETAILS_UPDATED = "DETAILS_UPDATED";
+
+export const eventTypes = [
+    DETAILS_UPDATED
+];

package/src/membership/user-profile/projections/current.js

@@ -0,0 +1,9 @@
+import { DETAILS_UPDATED } from "../events.js";
+import { patchViewWithSchema } from "../../../schema.js";
+
+export default schema => ({
+
+    [DETAILS_UPDATED]: (view, { payload }) =>
+        patchViewWithSchema({ view, payload, schema })
+
+});

package/src/membership/user-profile/store.js

@@ -0,0 +1,28 @@
+import { assertUserIsMe } from "../../rules.js";
+import { verifyStorePaths } from "../team-details/verify-store-paths.js";
+import { eventTypes } from "./events.js";
+import current from "./projections/current.js";
+
+export * from "./events.js";
+
+export function store(paths, schema) {
+
+    verifyStorePaths(paths, {
+        user: {
+            profile: { path: String }
+        }
+    });
+    if (!schema) throw new Error("Missing schema");
+    return {
+
+        ref: paths.user.profile.path,
+        projections: {
+            current: current(schema)
+        },
+        write: assertUserIsMe,
+        read: assertUserIsMe,
+        eventTypes
+
+    };
+
+}

package/src/membership/user-teams/events.js

@@ -0,0 +1,5 @@
+export const ADDED_TO_TEAM = "ADDED_TO_TEAM";
+
+export const LEFT_TEAM = "LEFT_TEAM";
+
+export const eventTypes = [ADDED_TO_TEAM, LEFT_TEAM];

package/src/membership/user-teams/projections/current.js

@@ -0,0 +1,21 @@
+import { ADDED_TO_TEAM, LEFT_TEAM } from "../events.js";
+
+export default {
+    [ADDED_TO_TEAM]: (view, { payload }) => {
+
+        if (!payload || typeof payload !== "object") return view;
+        if (!payload.tid) return view;
+        view.teams = Object.assign({}, view.teams, { [payload.tid]: Date.now() });
+        return view;
+
+    },
+    [LEFT_TEAM]: (view, { payload }) => {
+
+        if (!payload || typeof payload !== "object") return view;
+        if (!payload.tid) return view;
+        if (!view.teams) return view;
+        delete view.teams[payload.tid];
+        return view;
+
+    }
+};

package/src/membership/user-teams/store.js

@@ -0,0 +1,27 @@
+import { assertUserIsMe } from "../../rules.js";
+import { verifyStorePaths } from "../team-details/verify-store-paths.js";
+import { eventTypes } from "./events.js";
+import current from "./projections/current.js";
+
+export function store(paths) {
+
+    verifyStorePaths(paths, {
+        user: {
+            teams: { path: String }
+        }
+    });
+    return {
+
+        ref: paths.user.teams.path,
+        projections: {
+            current
+        },
+        eventTypes: eventTypes,
+        read: assertUserIsMe,
+        write: assertUserIsMe
+
+    };
+
+}
+
+export * from "./events.js";

package/src/membership/userInvites/events.js

@@ -0,0 +1,12 @@
+export const INVITED_TO_TEAM = "INVITED_TO_TEAM";
+
+export const ACCEPTED_INVITATION = "ACCEPTED_INVITATION";
+
+export const REJECTED_INVITATION = "REJECTED_INVITATION";
+
+
+export const eventTypes = [
+    INVITED_TO_TEAM,
+    ACCEPTED_INVITATION,
+    REJECTED_INVITATION
+];

package/src/membership/userInvites/projections/pending.js

@@ -0,0 +1,45 @@
+import { ACCEPTED_INVITATION, INVITED_TO_TEAM, REJECTED_INVITATION } from "../events.js";
+
+export default {
+
+    [INVITED_TO_TEAM]: (view, { meta, payload }) => {
+
+        if (!payload?.tid) return view;
+        if (!payload.id) return view;
+        if (!payload.email) return view;
+
+        view.email = payload.email || view.email;
+        view.invites = Object.fromEntries(Object
+            .entries(view.invites || {})
+            .filter(([_, invite]) => invite?.tid !== payload.tid) // filter out existing team invites
+            .concat([[
+                payload.id,
+                {
+                    ...payload,
+                    when: meta.when || new Date().toISOString()
+                }
+            ]]) // add the incoming one
+        );
+        return view;
+
+    },
+    [ACCEPTED_INVITATION]: (view, { payload }) => {
+
+        if (!payload?.id) return view;
+        if (!view.invites) return view;
+        if (!(payload.id in view.invites)) return view;
+        delete view.invites[payload.id];
+        return view;
+
+    },
+    [REJECTED_INVITATION]: (view, { payload }) => {
+
+        if (!payload?.id) return view;
+        if (!view.invites) return view;
+        if (!(payload.id in view.invites)) return view;
+        delete view.invites[payload.id];
+        return view;
+
+    }
+
+};

package/src/membership/userInvites/store.js

@@ -0,0 +1,46 @@
+import { eventTypes, ACCEPTED_INVITATION, REJECTED_INVITATION } from "./events.js";
+import pending from "./projections/pending.js";
+import { PROJECTIONS } from "../../index.js";
+import { verifyStorePaths } from "../team-details/verify-store-paths.js";
+import { all, any, assertEventIsOfType, assertDataFieldIsMyVerifiedEmail, assertMyVerifiedEmail, not, assertNewDataHas } from "../../rules.js";
+
+const assertAcceptedOrRejectedEvent = assertEventIsOfType(
+    ACCEPTED_INVITATION,
+    REJECTED_INVITATION
+);
+
+const assertAcceptedOrRejectedEvent_and_storeIsForMyVerifiedEmail = ({ userInvites: { path } }) =>
+    all(
+        assertAcceptedOrRejectedEvent,
+        assertMyVerifiedEmail(`${path}/${PROJECTIONS}/pending`)
+    );
+
+export function store(paths) {
+
+    verifyStorePaths(paths, {
+        userInvites: { path: String }
+    });
+
+    return {
+
+        ref: paths.userInvites.path,
+        projections: {
+            pending
+        },
+        eventTypes: eventTypes,
+        read: assertDataFieldIsMyVerifiedEmail("email"),
+        write: any(
+            assertAcceptedOrRejectedEvent_and_storeIsForMyVerifiedEmail(paths),
+            all(
+                not(assertAcceptedOrRejectedEvent),
+                assertNewDataHas("payload/email")
+            )
+        )
+
+    };
+
+}
+
+export * from "./events.js";
+
+

package/src/paths.js

@@ -0,0 +1,5 @@
+export function refPathToTriggerPath(ref) {
+
+    return ref.replaceAll(/\/\$([^/]*)/g, "/{$1}");
+
+}

package/src/rules.js

@@ -0,0 +1,153 @@
+import { PROJECTIONS } from "../dist/browser/client/event-store.js";
+
+export const any = (...args) =>
+
+    args.map(x => `(${x})`).join(" || ");
+
+export const all = (...args) =>
+
+    args.map(x => `(${x})`).join(" && ");
+
+export const not = x =>
+
+    `!(${x})`;
+
+const newDataField = fieldName =>
+
+    `newData.child('${fieldName}')`;
+
+export const newDataPayloadId =
+
+    `${newDataField("payload/id")}.val()`;
+
+export const newDataType =
+
+    `${newDataField("type")}.val()`;
+
+export const teamInviteToEmailMapping = ({ team: { membership: { path } } }) =>
+
+    `root.child('${path}/${PROJECTIONS}/inviteToEmail')`;
+
+export const assertDoesNotAlreadyExist =
+
+    "!data.exists()";
+
+export const assertIAmAuthenticated =
+
+    "auth.uid !== null";
+
+export const assertPayloadUidMyUserId =
+
+    `${newDataField("payload/uid")}.val() === auth.uid`;
+
+export const assertMyEmailVerified =
+
+    "auth.email_verified === true";
+
+export const assertDataFieldIsMyVerifiedEmail = fieldName =>
+
+    all(
+        `data.child('${fieldName}').val() == auth.email`,
+        assertMyEmailVerified
+    );
+
+export const assertMyVerifiedEmail = path =>
+
+    all(
+        `root.child('${path}/email').val() == auth.email`,
+        assertMyEmailVerified
+    );
+
+export const assertUserIsMe =
+
+    "$uid == auth.uid";
+
+export const assertMyUserIdIn = path =>
+
+    `root.child('${path}').child(auth.uid).exists()`;
+
+export const assertEventIsOfType = (...types) =>
+
+    `${newDataType}.matches(/^(${types.join("|")})$/)`;
+
+export const assertIsMyTeam = ({ team: { membership: { path } } }) =>
+
+    assertMyUserIdIn(`${path}/${PROJECTIONS}/members`);
+
+export const assertMyRoleIsAdmin = ({ team: { membership: { path } } }) =>
+
+    assertMyUserIdIn(`${path}/${PROJECTIONS}/details/admins`);
+
+
+export const assertNewDataHas = fieldName =>
+
+    `${newDataField(fieldName)}.exists()`;
+
+export const assertNewDataDoesNotHave = fieldName =>
+
+    `!${assertNewDataHas(fieldName)}`;
+
+const assertNewDataHasUncheckedString = fieldName =>
+
+    `${newDataField(fieldName)}.isString()`;
+
+const truthies = (...xs) => xs.filter(x => x);
+
+export const assertNewDataHasString = (fieldName, maxLength = 1000, minLength = 0) =>
+
+    all(
+        ...truthies(
+            assertNewDataHasUncheckedString(fieldName),
+            `${newDataField(fieldName)}.val().length <= ${maxLength}`,
+            minLength && `${newDataField(fieldName)}.val().length >= ${minLength}`
+        )
+    );
+
+
+export const assertNewDataHasNumber = fieldName =>
+
+    `${newDataField(fieldName)}.isNumber()`;
+
+const assertNewDataFieldValueMatches = (fieldName, pattern) =>
+
+    `${newDataField(fieldName)}.val().matches(/^${pattern}$/)`;
+
+export const assertNewDataHasFieldMatching = (fieldName, pattern) =>
+
+    all(
+        assertNewDataHasUncheckedString(fieldName),
+        assertNewDataFieldValueMatches(fieldName, pattern)
+    );
+
+const hexCharacters = "[0-9a-fA-F]";
+
+export const assertNewDataHasHexCharacters = (fieldName, characterCount) =>
+
+    assertNewDataHasFieldMatching(fieldName, `${hexCharacters}{${characterCount}}`);
+
+const lowerHexCharacters = "[0-9a-f]";
+
+export const assertNewDataHasLowercaseHexCharacters = (fieldName, characterCount) =>
+
+    assertNewDataHasFieldMatching(fieldName, `${lowerHexCharacters}{${characterCount}}`);
+
+const uuidPattern = [
+    `${hexCharacters}{8}`,
+    `${hexCharacters}{4}`,
+    `${hexCharacters}{4}`,
+    `${hexCharacters}{4}`,
+    `${hexCharacters}{12}`
+].join("-");
+
+export const assertNewDataHasUUID = fieldName =>
+
+    assertNewDataHasFieldMatching(fieldName, uuidPattern);
+
+
+export const assertNewDataHasOneOf = (fieldName, ...values) =>
+
+    assertNewDataHasFieldMatching(fieldName, `(${values.join("|")})`);
+
+export const assertNewDataFieldDoesNotMatch = (fieldName, pattern) =>
+
+    `!(${assertNewDataFieldValueMatches(fieldName, pattern)})`;