h1v3 0.7.1 → 0.7.2

package/dist/browser/client/context.js

@@ -20,21 +20,20 @@ function defaultHandleError(err) {
 
 }
 
-export async function inject({ database, configPath, handleError = defaultHandleError }) {
+export async function inject({ database, authentication, metaURL, handleError = defaultHandleError }) {
 
     if (!database) throw new Error("Missing database");
-    if (!configPath) throw new Error("Missing configPath");
-
-    const { db, ref, get } = database;
-    const snap = await get(ref(db, configPath));
-    const config = snap.val();
-
-    const log = logger(database, config.logs.path);
-    const teamMembershipStoreFactory = ({ tid }) => eventStore(database, populateParameters({ tid }, config.team.membership.path));
-    const teamDetailsStoreFactory = ({ tid }) => eventStore(database, populateParameters({ tid }, config.team.details.path));
-    const userInvitesStoreFactory = ({ emailId }) => eventStore(database, populateParameters({ emailId }, config.userInvites.path));
-    const userTeamsStoreFactory = ({ uid }) => eventStore(database, populateParameters({ uid }, config.user.teams.path));
-    const userProfileStoreFactory = ({ uid }) => eventStore(database, populateParameters({ uid }, config.user.profile.path));
+    if (!metaURL) throw new Error("Missing metaURL");
+    if (!authentication) throw new Error("Missing authentication");
+
+    const meta = await fetch(metaURL).then(resp => resp.json())
+
+    const log = logger(database, authentication, meta.o11y.path);
+    const teamMembershipStoreFactory = ({ tid }) => eventStore(database, authentication, populateParameters({ tid }, meta.team.membership.path));
+    const teamDetailsStoreFactory = ({ tid }) => eventStore(database, authentication, populateParameters({ tid }, meta.team.details.path));
+    const userInvitesStoreFactory = ({ emailId }) => eventStore(database, authentication, populateParameters({ emailId }, meta.userInvites.path));
+    const userTeamsStoreFactory = ({ uid }) => eventStore(database, authentication, populateParameters({ uid }, meta.user.teams.path));
+    const userProfileStoreFactory = ({ uid }) => eventStore(database, authentication, populateParameters({ uid }, meta.user.profile.path));
 
     return {
 

package/dist/browser/client/event-store.js

@@ -5,11 +5,13 @@ const newEventId = eventType => `${timeId()}-${eventType}`;
 export const PROJECTIONS = "_p";
 export const EVENTS = "_e";
 
-export function eventStore(database, path) {
+export function eventStore(database, authentication, path) {
 
     const { db, ref, onValue, get, set } = database;
     for (const required of ["db", "ref", "onValue", "get", "set"])
         if (!database[required]) throw new Error(`Missing required database.${required}`);
+    const { auth } = authentication;
+    if (!auth) throw new Error("Missing required authentication.auth");
 
     const eventsPath = `${path}/${EVENTS}`;
     const projectionsPath = `${path}/${PROJECTIONS}`;
@@ -46,8 +48,13 @@ export function eventStore(database, path) {
         async record(eventType, payload) {
 
             const eid = newEventId(eventType);
-            const data = { type: eventType, payload, meta: { when: new Date().toISOString() } };
-            await set(ref(db, `${eventsPath}/${eid}`), data);
+            const meta = {
+                when: new Date().toISOString(),
+                uid: authentication.auth?.currentUser?.uid
+            };
+            const data = { type: eventType, payload, meta };
+            const path = `${eventsPath}/${eid}`;
+            await set(ref(db, path), data);
 
         },
 

package/dist/browser/client/logger.js

@@ -11,22 +11,16 @@ function munge(attributes) {
 
 }
 
-export function logger(database, path, defaultAttributes) {
+export function logger(database, authentication, path, defaultAttributes) {
 
     const { db, ref, set } = database;
-    const record = data => {
-
-        const refPath = path.replace("$id", timeId());
-        console.log("Logging", data, "to", refPath);
-        return set(ref(db, refPath), data);
-
-    };
 
     async function recordLog(trace_id, level, sharedAttributes, { body, parent_id, attributes }) {
 
         const span_id = generateSpanId();
         console.log(defaultAttributes, sharedAttributes, attributes);
         const data = {
+            meta: { uid: authentication.auth.currentUser.uid },
             body,
             trace_id,
             span_id,
@@ -35,7 +29,10 @@ export function logger(database, path, defaultAttributes) {
             attributes: munge({ ...defaultAttributes, ...sharedAttributes, ...attributes })
         };
         if (parent_id) data.parent_id = parent_id;
-        await record(data);
+        const refPath = path.replace("$id", timeId());
+        console.log("Logging", data, "to", refPath);
+        return await set(ref(db, refPath), data);
+
 
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h1v3",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "",
   "license": "MIT",
   "author": "",

package/src/client/context.js

@@ -4,6 +4,7 @@ import { user } from "../../dist/browser/client/team/user.js";
 
 export function inject({
     db,
+    uid: authorUid,
     teamMembershipConfig,
     userTeamsConfig,
     userInvitesConfig,
@@ -16,14 +17,15 @@ export function inject({
     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");
+    if (!db || (typeof db !== "object")) throw new Error("Missing object: db");
+    if (!authorUid || (typeof authorUid !== "string")) throw new Error("Missing string: uid");
 
     return {
 
         team({ tid }) {
 
-            const teamMembershipStore = eventStoreFromConfig(db, teamMembershipConfig, { tid });
-            const teamDetailsStore = eventStoreFromConfig(db, teamDetailsConfig, { tid });
+            const teamMembershipStore = eventStoreFromConfig(db, authorUid, teamMembershipConfig, { tid });
+            const teamDetailsStore = eventStoreFromConfig(db, authorUid, teamDetailsConfig, { tid });
             return team({
                 teamMembershipStore,
                 teamDetailsStore,
@@ -35,8 +37,8 @@ export function inject({
 
         userProfile({ uid }) {
 
-            const userTeamsStore = eventStoreFromConfig(db, userTeamsConfig, { uid });
-            const userProfileStore = eventStoreFromConfig(db, userProfileConfig, { uid });
+            const userTeamsStore = eventStoreFromConfig(db, authorUid, userTeamsConfig, { uid });
+            const userProfileStore = eventStoreFromConfig(db, authorUid, userProfileConfig, { uid });
             return user({ userTeamsStore, userProfileStore });
 
         }
@@ -45,13 +47,13 @@ export function inject({
 
     function userTeamsStoreFactory({ uid }) {
 
-        return eventStoreFromConfig(db, userTeamsConfig, { uid });
+        return eventStoreFromConfig(db, authorUid, userTeamsConfig, { uid });
 
     }
 
     function userInvitesStoreFactory({ emailId }) {
 
-        return eventStoreFromConfig(db, userInvitesConfig, { emailId });
+        return eventStoreFromConfig(db, authorUid, userInvitesConfig, { emailId });
 
     }
 

package/src/client/node.js

@@ -1,7 +1,7 @@
 import { EVENT_STORE_META } from "../event-store/configuration.js";
 import { eventStore as eventStoreModular } from "../../dist/browser/client/event-store.js";
 
-function adapter(db) {
+function adaptDatabase(db) {
 
     return {
         db,
@@ -42,16 +42,33 @@ function resolvePath(pathTemplate, pathValues) {
 
 }
 
-export function eventStoreFromConfig(db, config, pathValues = {}) {
+export function eventStoreFromConfig(db, uid, config, pathValues = {}) {
+
+    if (!db || typeof db !== "object") throw new Error(`Expected object for db: ${db}`);
+    if (!uid || typeof uid !== "string") throw new Error(`Expected string for uid: ${uid}`);
+    if (!config || !(EVENT_STORE_META in config)) throw new Error(`Expected config tagged with event store metadata: ${config}`);
 
     const meta = config[EVENT_STORE_META];
-    return  eventStore(db, resolvePath(meta.ref, pathValues));
+    return  eventStore(db, uid, resolvePath(meta.ref, pathValues));
 
 }
 
-export function eventStore(db, path) {
+export function eventStore(db, uid, path) {
+
+    if (!db || typeof db !== "object") throw new Error(`Expected object for db: ${db}`);
+    if (!uid || typeof uid !== "string") throw new Error(`Expected string for uid: ${uid}`);
+    if (!path || typeof path !== "string") throw new Error(`Expected string for path: ${path}`);
 
-    const firebase = adapter(db);
-    return eventStoreModular(firebase, path);
+    return eventStoreModular(
+        adaptDatabase(db),
+        adaptAuthentication(uid),
+        path
+    );
+
+}
 
-}
+function adaptAuthentication(uid) {
+
+    return { auth: { currentUser: { uid } } };
+
+}

package/src/commands/generate-rules.js

@@ -1,10 +1,11 @@
 import { EVENTS, PROJECTIONS } from "../../dist/browser/client/event-store.js";
 import { explodePathVars } from "../index.js";
+import { writeFileSync } from "node:fs";
 
 function writeConditions(config) {
 
     if (config.write === false) return false;
-    let expr = "auth.uid != null && !data.exists()";
+    let expr = "(auth.uid!=null) && !data.exists() && (newData.child('meta/uid').val()==auth.uid)";
     if (config?.write)
         expr += " && (" + explodePathVars(config.write) + ")"
     return expr;
@@ -93,18 +94,29 @@ const parseConfig = ([_name, config]) => [
     config
 ];
 
-export function generateRules(_argv, eventStores, rawStores) {
+export function generateRules(argv, eventStores, rawStores) {
 
-    console.log(
-        JSON.stringify(
+
+    const rulesJSON = JSON.stringify(
         {
             rules: [
                 ...eventStores.map(parseConfig),
                 ...rawStores.map(parseConfig)
             ].reduce(addRulesForPath, {})
         },
-        null, 4)
+        null,
+        4
     );
+    if (argv.output) {
+
+        console.log("Writing to", argv.output);
+        writeFileSync(argv.output, rulesJSON);
+
+    } else {
+
+        console.log(rulesJSON);
+
+    }
 
 }
 

package/src/configuration.js

@@ -1,3 +1,4 @@
+import { loadConfigurationFromModule } from "./load-configuration.js";
 import { refPathToTriggerPath } from "./paths.js";
 import { all, assertNewDataDoesNotHave, assertNewDataHasString, any, assertNewDataHasNumber, assertNewDataHasOneOf, assertNewDataHasLowercaseHexCharacters, assertNewDataFieldDoesNotMatch } from "./rules.js";
 
@@ -17,21 +18,72 @@ export function configureConfigStore(paths, _onValueWritten, _observe) {
 
 }
 
+function buildConfigDigest(module, paths) {
+
+
+    const refConfigMap =
+        loadConfigurationFromModule(module)
+        .flatMap(x => x.map(y => y[1]))
+        .reduce((index, config) => ({ ...index, [config.ref]: config }), {});
+
+    function patchForPath(map) {
+
+        const ret = {
+            ...map
+        };
+        const mappedConfig = refConfigMap[map.path];
+        for (const [x, y] of Object.entries(ret).filter(([_, v]) => typeof v === "object")) {
+
+            ret[x] = patchForPath(y);
+
+        }
+        if (mappedConfig && (mappedConfig.read || mappedConfig.write)) {
+
+            ret.projections = mappedConfig.projections;
+            ret.eventTypes = mappedConfig.eventTypes;
+
+        }
+        return ret;
+
+    }
+
+    return patchForPath(paths);
+
+}
+
+const publicFor1Day = "public, max-age=86400";
+
+export function configureMetadataEndpoint({ module, paths, onRequest, region, cacheControl = publicFor1Day }) {
+
+    const digest = buildConfigDigest(module, paths);
+    return onRequest(
+        { region },
+        async (_, res) => {
+
+            res.header("Cache-Control", cacheControl).send(digest);
+
+        }
+    );
+
+}
+
 const googleLogLevels = ["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"];
 
 function decideSeverity(newData) {
 
     const text = newData.severity_text?.toUpperCase();
-    return googleLogLevels.includes(text) ? text : "info";
+    return googleLogLevels.includes(text) ? text : "INFO";
 
 }
 
-function decideMessage(newData) {
-
-    return newData?.body || "Log message without body";
+/*
 
-}
+    message, severity, // required
+    traceId, spanId, timestamp, // advised
+    logData, // optional log line
+    spanStart, spanEnd, spanAttributes // optional trace attributes
 
+*/
 function handleO11yEventWritten(observe, e) {
 
     const { after } = e.data;
@@ -41,16 +93,21 @@ function handleO11yEventWritten(observe, e) {
         const now = new Date();
         const time_server_ms = now.valueOf();
         const timestamp = now.toISOString();
+        const message = newData?.message || "Missing log message";
+
+        const { traceId, spanId, ...rest } = newData
+        const logData = { ...rest, time_server_ms };
+
         observe({
-            "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
+            message,
+            severity: decideSeverity(newData),
+
+            traceId: newData.trace_id,
+            spanId: newData.span_id,
+            timestamp,
+
+            logData
+
         });
         after.ref.update({ time_server_ms });
 

package/src/event-store/configuration.js

@@ -6,8 +6,8 @@ export const EVENT_STORE_META = Symbol("Event store configuration metadata");
 
 export function configureEventStore({ ref, projections, ...rest }, { onValueWritten, observe, region, instance }) {
 
-    if (!onValueWritten) throw new Error("Missing onValueWritten");
-    if (!observe) throw new Error("Missing observe");
+    if (typeof onValueWritten !== "function") throw new Error(`Missing onValueWritten function: ${onValueWritten}`);
+    if (typeof observe !== "function") throw new Error(`Missing observe function: ${observe}`);
     if (!region) throw new Error("Missing region");
     if (!instance) throw new Error("Missing instance");
 

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,38 +35,6 @@ main({
         strategy: generateRules
 
     },
-    // "vendor-eventstore": {
-
-    //     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",

package/src/index.js

@@ -33,4 +33,6 @@ export function explodePathVars(expr) {
 
 }
 
-export * as o11y from "./observability/index.js";
+export * as o11y from "./observability/index.js";
+
+export { loadConfigurationFromModule } from "./load-configuration.js";

package/src/load-configuration.js

@@ -9,11 +9,15 @@ export async function loadConfiguration(argv) {
     if (!argv.snippet)
         console.log("Loading configuration:", configPath);
     const module = await import(pathToFileURL(configPath));
+    return loadConfigurationFromModule(module)
+
+}
+
+export function loadConfigurationFromModule(module) {
     return [
         readStoresMetadata(module),
         readRawMetadata(module)
-    ]
-
+    ];
 }
 
 export function readRawMetadata(config) {

package/src/observability/index.js

@@ -1,4 +1,4 @@
-export async function provider({ trace, projectId, serviceName, log }) {
+export function provider({ trace, projectId, serviceName, log }) {
 
     if (!serviceName) throw new Error("Missing serviceName");
     if (!trace) throw new Error("Missing trace");
@@ -44,7 +44,7 @@ function generateLowerHex(byteLength) {
 
 }
 
-export function toTraceAttributes(obj) {
+function toTraceAttributes(obj) {
 
     const attributeMap = {};
     for (const [key, value] of Object.entries(obj)) {
@@ -81,8 +81,6 @@ async function writeLogLine({ log, projectId }, { message, tracePath, spanId, se
         traceSampled: "true",
         timestamp
     };
-    console.log("Log meta", logMeta);
-
     const entry = log.entry(
         logMeta,
         {