h1v3 0.4.1 → 0.6.1

package/src/commands/vendor.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { existsSync  } from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -12,13 +13,11 @@ async function readPackageJSON() {
 
 async function vendor(subpath) {
 
-    const { version, name } = await readPackageJSON();
     const src = join(__dirname, "..", "..", "dist", "browser", subpath);;
 
-
     // Destination: include semver
-    const versionedName = `${name}@${version}`;
-    const dest =join(".", "public", "vendor", versionedName, subpath);
+    const versionedName = await versionedPackageName();
+    const dest =join(destVendorPath(), versionedName, subpath);
 
     // Recursive copy
     await fs.cp(src, dest, { recursive: true });
@@ -26,35 +25,99 @@ async function vendor(subpath) {
 
 }
 
-export async function eventStore(_argv) {
+async function versionedPackageName() {
+
+    const { version, name } = await readPackageJSON();
+    const versionedName = `${name}@${version}`;
+    return versionedName;
+
+}
+
+function destVendorPath() {
+
+    return join(process.cwd(), "public", "vendor");
+
+}
+
+// export async function eventStore(_argv) {
+
+//     await vendor("event-store");
+
+// }
+
+// export async function webPlatform(_argv) {
 
-    await vendor("event-store");
+//     await vendor("web");
+
+// }
+
+export async function deps(_argv) {
+
+    // lit
+    const dest = join(destVendorPath(), "lit@3.3.1", "dist");
+    const destFile = join(dest, "lit-core.min.js");
+    if (existsSync(destFile)) {
+
+        console.log("Skipping", destFile);
+
+    } else {
+
+        const resp = await fetch("https://cdn.jsdelivr.net/gh/lit/dist@3.3.1/core/lit-core.min.js")
+        const lit = await resp.text();
+        await fs.mkdir(dest, { recursive: true });
+        await fs.writeFile(destFile, lit);
+        console.log("Vendored", destFile);
+
+    }
 
 }
 
-export async function webPlatform(_argv) {
+export async function client(_argv) {
 
-    await vendor("web");
+    await vendor("client");
 
 }
 
-export async function webPlatformUI(_argv) {
+// export async function webPlatformUI(_argv) {
+
+//     await webPlatform(_argv);
+//     await vendor("web-ui");
+//     const resp = await fetch("https://cdn.jsdelivr.net/gh/lit/dist@3.3.1/core/lit-core.min.js")
+//     const lit = await resp.text();
+//     const dest = join(".", "public", "vendor", "lit@3.3.1", "dist");
+//     await fs.mkdir(dest, { recursive: true });
+//     await fs.writeFile(
+//         join(".", "public", "vendor", "lit@3.3.1", "dist", "lit-core.min.js"),
+//         lit
+//     );
 
-    await webPlatform(_argv);
-    await vendor("web-ui");
-    const resp = await fetch("https://cdn.jsdelivr.net/gh/lit/dist@3.3.1/core/lit-core.min.js")
-    const lit = await resp.text();
-    const dest = join(".", "public", "vendor", "lit@3.3.1", "dist");
-    await fs.mkdir(dest, { recursive: true });
-    await fs.writeFile(
-        join(".", "public", "vendor", "lit@3.3.1", "dist", "lit-core.min.js"),
-        lit
-    );
+// }
+
+// export async function membership(_argv) {
+
+//     await eventStore(_argv);
+//     await vendor("team");
+
+// }
+
+export async function symLinkLatest(_argv) {
+
+    const vendorPath = destVendorPath();
+    const versionedName = await versionedPackageName();
+
+    const path = join(vendorPath, "h1v3@latest");
+    const target = join(vendorPath, versionedName);
+    await fs.unlink(path);
+    await fs.symlink(versionedName, path, "dir");
+
+    console.log("Symlinked", versionedName, "to", path);
 
 }
 
-export async function membership(_argv) {
+export async function all(argv) {
+
+    await deps(argv);
+    await client(argv);
+    await symLinkLatest(argv)
 
-    await eventStore(_argv);
-    await vendor("team");
 }

package/src/configuration.js

@@ -0,0 +1,116 @@
+import { refPathToTriggerPath } from "./paths.js";
+import { all, assertNewDataDoesNotHave, assertNewDataHasString, any, assertNewDataHasNumber, assertNewDataHasOneOf, assertNewDataHasLowercaseHexCharacters, assertNewDataFieldDoesNotMatch } from "./rules.js";
+
+export const RAW_STORE_META = Symbol("Raw database metadata");
+
+export function configureConfigStore(paths, _onValueWritten, _logger) {
+
+    if (!paths?.config?.path) throw new Error("Missing: paths.config.path");
+    return {
+        [RAW_STORE_META]: {
+            raw: true,
+            ref: paths.config.path,
+            read: true,
+            write: false
+        }
+    };
+
+}
+
+function decideSeverity(newData) {
+
+    if (!newData.severity_text) return "INFO";
+    return newData.severity_text.toUpperCase();
+
+}
+
+function decideMessage(newData) {
+
+    return newData?.body || "Log message without body";
+
+}
+
+function handleLogValueWritten(logger, e) {
+
+    const { after } = e.data;
+    const newData = after.val();
+    if (!newData.time_server_ms) {
+
+        const now = new Date();
+        const time_server_ms = now.valueOf();
+        const timestamp = now.toISOString();
+        const payload = {
+            "logging.googleapis.com/trace": `projects/${process.env.GCLOUD_PROJECT}/traces/${newData.trace_id}`,
+            "logging.googleapis.com/spanId": newData.span_id,
+            "message": decideMessage(newData),
+            "severity": decideSeverity(newData),
+            "raw": {
+                ...newData,
+                time_server_ms
+            },
+            timestamp
+        };
+        console.log("Writing log", payload);
+        logger.write(payload);
+        after.ref.update({ time_server_ms });
+
+    }
+
+}
+
+export function configureLoggingStore({ paths, onValueWritten, logger, region, instance }) {
+
+    if (!paths) throw new Error("Missing paths");
+    if (!onValueWritten) throw new Error("Missing onValueWritten");
+    if (!logger) throw new Error("Missing logger");
+    if (!region) throw new Error("Missing region");
+    if (!instance) throw new Error("Missing instance");
+
+    const ref = paths?.logs?.path;
+    if (!ref) throw new Error("Missing: paths.logs.path");
+    const triggerPath = refPathToTriggerPath(ref);
+    return Object.assign(
+        onValueWritten({
+            ref: triggerPath,
+            region,
+            instance
+        }, handleLogValueWritten.bind(this, logger)),
+        {
+            [RAW_STORE_META]: {
+                raw: true,
+                ref,
+                read: false,
+                write: all(
+                    // required
+                    assertNewDataHasString("body", 500, 1),
+                    assertNewDataHasOneOf("severity_text", "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"),
+                    // trace context
+                    all(
+                        assertNewDataHasLowercaseHexCharacters("trace_id", 32),
+                        assertNewDataFieldDoesNotMatch("trace_id", "0*")
+                    ),
+                    all(
+                        assertNewDataHasLowercaseHexCharacters("span_id", 16),
+                        assertNewDataFieldDoesNotMatch("span_id", "0*")
+                    ),
+                    // forbid server time faking
+                    assertNewDataDoesNotHave("time_server_ms"),
+                    // optional bits
+                    any(
+                        assertNewDataDoesNotHave("time_client_ms"),
+                        assertNewDataHasNumber("time_client_ms")
+                    ),
+                    any(
+                        assertNewDataDoesNotHave("parent_id"),
+                        all(
+                            assertNewDataHasLowercaseHexCharacters("parent_id", 16),
+                            assertNewDataFieldDoesNotMatch("parent_id", "0*")
+                        )
+                    )
+                )
+            }
+        }
+    );
+
+}
+

package/src/event-store/configuration.js

@@ -0,0 +1,44 @@
+import { EVENTS } from "../../dist/browser/client/event-store.js";
+import { updateProjections } from "./projections.js";
+import { refPathToTriggerPath } from "../paths.js";
+
+export const EVENT_STORE_META = Symbol("Event store configuration metadata");
+
+export function configureEventStore({ ref, projections, ...rest }, { onValueWritten, logger, region, instance }) {
+
+    if (!onValueWritten) throw new Error("Missing onValueWritten");
+    if (!logger) throw new Error("Missing logger");
+    if (!region) throw new Error("Missing region");
+    if (!instance) throw new Error("Missing instance");
+
+    // considered the "home" of the event store, under which events and projections will be stored
+    const eventStorePath = refPathToTriggerPath(ref);
+
+    // the path which will trigger event store projections
+    const writeRefPath = `${eventStorePath}/${EVENTS}/{eid}`;
+
+    // handle an incoming write event
+    const handler = e => updateProjections(e.data.after, projections, logger, rest.debug);
+
+    const metadata = {
+        ...rest,
+        ref,
+        triggerPath: writeRefPath,
+        projections: Object.keys(projections)
+    };
+
+    // tag the trigger with metadata
+    return Object.assign(
+        onValueWritten({ ref: writeRefPath, region, instance }, handler),
+        { [EVENT_STORE_META]: metadata }
+    );
+
+}
+
+configureEventStore.inject = ({ onValueWritten, logger, paths, region, instance }) =>
+
+    (eventStoreFactory, ...args) =>
+
+            configureEventStore(eventStoreFactory(paths, ...args), { onValueWritten, logger, region, instance });
+
+

package/src/event-store/projections.js

@@ -1,4 +1,7 @@
-export async function updateProjections(incomingEventSnap, projectionTransformationPerEvent, logger) {
+import { PROJECTIONS } from "../../dist/browser/client/event-store.js";
+import { inspect } from "node:util";
+
+export async function updateProjections(incomingEventSnap, projectionTransformationPerEvent, logger, debug = false) {
 
     // order the events
     const eventsSnap = await incomingEventSnap.ref.parent.get();
@@ -9,29 +12,55 @@ export async function updateProjections(incomingEventSnap, projectionTransformat
     for(const [key, transformations] of projections) {
 
         const fallbackTransformation = transformations["?"];
+        const trace = [key];
+        const context = {
+            projection: key
+        };
         const view = sortedEvents.reduce(
-            (agg, e) => {
+            (agg, [eventKey, eventValue]) => {
 
-                const transform = transformations[e[1]?.type] || fallbackTransformation || missingTransform;
-                return transform(agg, e[1], e[0]);
+                context.eventId = eventKey;
+                if (debug) trace.push(agg, e);
+                const transform = transformations[eventValue?.type] || fallbackTransformation || missingTransformFor(key);
+                return transform(agg, eventValue, context);
 
             }, {});
+
+        if (debug) console.debug(...trace, view);
         await writeProjection(incomingEventSnap, key, view);
 
     }
 
-    function missingTransform(agg, e) {
+    function missingTransformFor(projection) {
+
+        return (agg, e) => {
+
+            logger.warn("Missing transform for event", { projection, event: e });
+            return agg;
 
-        logger.warn("Missing transformation for event", { event: e });
-        return agg;
+        };
 
     }
 
-    async function writeProjection(incomingEventSnap, key, view) {
+    async function writeProjection(incomingEventSnap, projection, view) {
+
+        const projectionRef = incomingEventSnap.ref.parent.parent.child(PROJECTIONS).child(projection);
+        const incomingEvent = incomingEventSnap.val();
+        logger.info("Writing projection after event", {
+            path: projectionRef,
+            incomingEvent
+        });
+        try {
+
+            await projectionRef.set(view);
+
+        } catch(err) {
+
+            const data = inspect(view).replace(/\n */g, " ");
+            const path = projectionRef.toString();
+            logger.error(`Error writing projection: ${err?.message}`, { projection, path, data });
 
-        const projectionRef = incomingEventSnap.ref.parent.parent.child("projections").child(key);
-        logger.info("Writing projection after event", { path: projectionRef, incomingEvent: incomingEventSnap.val() });
-        await projectionRef.set(view);
+        }
 
     }
 

package/src/exec-eventstore.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { listEventStores } from "./commands/list-event-stores.js";
 import { generateRules } from "./commands/generate-rules.js";
@@ -35,37 +35,71 @@ main({
         strategy: generateRules
 
     },
-    "vendor-eventstore": {
+    // "vendor-eventstore": {
 
-        description: "Copy event store client into your browser assets folder",
+    //     description: "Copy event store client into your browser assets folder",
+    //     loadConfig: false,
+    //     parameters: {},
+    //     strategy: vendor.eventStore
+
+    // },
+    // "vendor-web": {
+
+    //     description: "Copy web logic platform into your browser assets folder",
+    //     loadConfig: false,
+    //     parameters: {},
+    //     strategy: vendor.webPlatform
+
+    // },
+    // "vendor-webui": {
+
+    //     description: "Copy web UI platform into your browser assets folder (requires web)",
+    //     loadConfig: false,
+    //     parameters: {},
+    //     strategy: vendor.webPlatformUI
+
+    // },
+    // "vendor-membership": {
+
+    //     description: "Copy team management logic into your browser assets folder",
+    //     loadConfig: false,
+    //     parameters: {},
+    //     strategy: vendor.membership
+
+    // },
+    "vendor-link": {
+
+        description: "Symlink latest vendored h1v3 assets as h1v3@latest",
         loadConfig: false,
         parameters: {},
-        strategy: vendor.eventStore
+        strategy: vendor.symLinkLatest
 
     },
-    "vendor-web": {
 
-        description: "Copy web logic platform into your browser assets folder",
+    "vendor-client": {
+
+        description: "Copy all h1v3 logic into your browser assets folder",
         loadConfig: false,
         parameters: {},
-        strategy: vendor.webPlatform
+        strategy: vendor.client
 
     },
-    "vendor-webui": {
 
-        description: "Copy web UI platform into your browser assets folder (requires web)",
+    "vendor-deps": {
+
+        description: "Copy all external dependencies for h1v3 into your browser assets folder",
         loadConfig: false,
         parameters: {},
-        strategy: vendor.webPlatformUI
+        strategy: vendor.deps
 
     },
-    "vendor-membership": {
 
-        description: "Copy team management logic into your browser assets folder",
+    "vendor-all": {
+
+        description: "Copy all h1v3 logic into your browser assets folder",
         loadConfig: false,
         parameters: {},
-        strategy: vendor.membership
-
+        strategy: vendor.all
     }
 
 });

package/src/index.js

@@ -1,4 +1,8 @@
-export * from "./event-store/initialise.js";
+export { PROJECTIONS, EVENTS } from "../dist/browser/client/event-store.js";
+
+export * from "./event-store/configuration.js";
+
+export * from "./configuration.js";
 
 export const passThroughView = {
     "?": (view, e, key) => {
@@ -10,9 +14,21 @@ export const passThroughView = {
     }
 };
 
-export function ifUserIdExists(path) {
+export * as userProfile from "./membership/user-profile/store.js";
+
+export * as teamMembership from "./membership/team-membership/store.js";
+
+export * as teamDetails from "./membership/team-details/store.js";
+
+export * as userTeams from "./membership/user-teams/store.js";
+
+export * as userInvites from "./membership/userInvites/store.js";
+
+export * as rules from "./rules.js";
+
+export function explodePathVars(expr) {
 
-    const expr = `root.child('${path}/' + auth.uid).exists()`;
-    return expr.replaceAll(/(\$[^/]*)/g, "' + $1 + '")
+    if (typeof expr !== "string") return expr;
+    return expr.replaceAll(/\/(\$[^/]*)/g, "/' + $1 + '");
 
 }

package/src/load-configuration.js

@@ -1,6 +1,7 @@
 import { resolve } from "path";
 import { pathToFileURL } from "url";
-import { EVENT_STORE_META } from "./event-store/initialise.js";
+import { EVENT_STORE_META } from "./event-store/configuration.js";
+import { RAW_STORE_META } from "./configuration.js";
 
 export async function loadConfiguration(argv) {
 
@@ -8,7 +9,19 @@ export async function loadConfiguration(argv) {
     if (!argv.snippet)
         console.log("Loading configuration:", configPath);
     const module = await import(pathToFileURL(configPath));
-    return readStoresMetadata(module);
+    return [
+        readStoresMetadata(module),
+        readRawMetadata(module)
+    ]
+
+}
+
+export function readRawMetadata(config) {
+
+    return Object.entries(config)
+        .map(([k, v]) => [k, v?.[RAW_STORE_META]])
+        .filter(x => x[1])
+        ;
 
 }
 
@@ -16,6 +29,7 @@ export function readStoresMetadata(config) {
 
     return Object.entries(config)
         .map(([k, v]) => [k, v?.[EVENT_STORE_META]])
-        .filter(x => x[1]);
+        .filter(x => x[1])
+        ;
 
 }

package/src/membership/index.js

@@ -1,3 +1,5 @@
-export * as userProfile from "./user-profile-store.js";
-export * as membership from "./membership-store.js";
-export * as userTeams from "./user-teams-store.js";
+export * as userProfile from "./user-profile/store.js";
+export * as teamMembership from "./team-membership/store.js";
+export * as teamDetails from "./team-details/store.js";
+export * as userTeams from "./user-teams/store.js";
+export * as userInvites from "./userInvites/store.js";

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

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

package/src/membership/team-details/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/team-details/store.js

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

package/src/membership/team-details/verify-store-paths.js

@@ -0,0 +1,8 @@
+import { checkSchema } from "../../schema.js";
+
+export function verifyStorePaths(paths, schema) {
+
+    const { valid, errors } = checkSchema(schema, paths, { allowUnknownKeys: true, requireAllKeys: true });
+    if (!valid) throw new Error(`Store paths:\n - ${errors.join("\n - ")}`);
+
+}

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

@@ -0,0 +1,17 @@
+export const BECAME_MEMBER = "BECAME_MEMBER";
+export const BECAME_ADMIN = "BECAME_ADMIN";
+export const LEFT_TEAM = "LEFT_TEAM";
+export const MEMBER_INVITED = "MEMBER_INVITED";
+export const ADMIN_INVITED = "ADMIN_INVITED";
+export const INVITE_ACCEPTED = "INVITE_ACCEPTED";
+export const INVITE_REJECTED = "INVITE_REJECTED";
+
+export const eventTypes = [
+    BECAME_MEMBER,
+    BECAME_ADMIN,
+    LEFT_TEAM,
+    MEMBER_INVITED,
+    ADMIN_INVITED,
+    INVITE_ACCEPTED,
+    INVITE_REJECTED
+];

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

@@ -0,0 +1,55 @@
+
+export function resolveInvitationView(payload, meta) {
+
+    return {
+        id: payload.id,
+        name: payload.name || "",
+        email: payload.email || "",
+        created: meta?.when || "",
+        createdBy: payload.createdBy || ""
+    };
+
+}
+
+export function resolveUserView({ name, email, createdBy }, found, meta) {
+
+    name = name || found?.name || "";
+    email = email || found?.email;
+    const view = {
+        name
+    };
+    if (meta?.when) view.updated = meta.when;
+    if (email) view.email = email;
+    if (createdBy) view.createdBy = createdBy;
+    return view;
+
+}
+
+export function purgeInvited(view, key) {
+
+    if (view.invitedMembers && (key in view.invitedMembers))
+        delete view.invitedMembers[key];
+    if (view.invitedAdmins && (key in view.invitedAdmins))
+        delete view.invitedAdmins[key];
+
+}
+
+export function purgeUser(view, { uid }) {
+
+    const found = view.members?.[uid] || view.admins?.[uid] || view.owners?.[uid];
+    if (view.members && (uid in view.members))
+        delete view.members[uid];
+    if (view.admins && (uid in view.admins))
+        delete view.admins[uid];
+    return found;
+
+}
+
+export const passThrough = x => x;
+export function recordInviteInContext(context, id, data) {
+
+    context.invites = context.invites || {};
+    context.invites[id] = data;
+
+}
+