anbaric-state-machine 1.18.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-state-machine",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "This is the state machine library that one can use to add state management to an application. It will, by default, be locally runnable but can deployed to the Anbaric Cloud via the CLI",
   "license": "MIT",
   "author": "chris@anbaric.ai",
@@ -15,8 +15,8 @@
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "anbaric-impl-cloud": "^1.18.0",
-    "anbaric-tsapi": "^1.18.0"
+    "anbaric-impl-cloud": "^1.19.0",
+    "anbaric-tsapi": "^1.19.0"
   },
   "files": [
     "src"

package/src/StateMachine.ts

@@ -65,7 +65,7 @@ class StateMachine {
                 actions: state.actions.map(action => ({
                     name: action.name,
                     description: action.description,
-                    actor: { id: action.actor.id, type: action.actor.type, role: action.actor.role },
+                    actor: { id: action.actor.id, type: action.actor.type, roles: action.actor.roles },
                 })),
                 transitions: state.transitions.map(transition => ({ to: transition.to })),
             })),

package/src/actors/Code.ts

@@ -4,11 +4,11 @@ class Code implements Actor {
 
     readonly type = "CODE" as const;
     readonly id : string;
-    readonly role : string;
+    readonly roles : Array<string>;
 
-    constructor(id : string, role : string = "code") {
+    constructor(id : string, roles : Array<string> | string = "code") {
         this.id = id;
-        this.role = role;
+        this.roles = typeof roles === "string" ? [roles] : roles;
     }
 
 }

package/src/actors/Human.ts

@@ -1,18 +1,30 @@
-import {Actor} from "anbaric-tsapi";
+import {IncomingMessage} from "node:http";
+import {Actor, SessionResolver} from "anbaric-tsapi";
+import {SessionResolverFactory} from "../sessions/SessionResolverFactory";
+import {sessionCookie} from "../sessions/sessionCookie";
 
 class Human implements Actor {
 
     readonly type = "HUMAN" as const;
     readonly id : string;
-    readonly role : string;
+    readonly roles : Array<string>;
 
-    constructor(id : string, role : string) {
+    constructor(id : string, roles : Array<string> | string) {
         this.id = id;
-        this.role = role;
+        this.roles = typeof roles === "string" ? [roles] : roles;
     }
 
-    static createFromSession() {
-
+    /* Resolves the browser user behind a request to an app page into a Human,
+       for auditing. Takes the platform session - either the anbaric_session
+       token, or the incoming request to read the cookie from - and asks the
+       platform to verify it (an app cannot: the signing secret is platform
+       only). */
+    static async fromSession(source : string | IncomingMessage,
+                             resolver : SessionResolver = SessionResolverFactory.instance()) : Promise<Human> {
+        const token = typeof source === "string" ? source : sessionCookie(source);
+        const session = token ? await resolver.resolve(token) : undefined;
+        if (!session) throw new Error("Could not resolve the session");
+        return new Human(session.id, session.roles);
     }
 
 }

package/src/index.ts

@@ -11,3 +11,6 @@ export * from "./scheduling/InMemoryQueue";
 export * from "./scheduling/PullConsumer";
 export * from "./scheduling/ConsumerFactory";
 export * from "./scheduling/QueueFactory";
+export * from "./sessions/InMemorySessionResolver";
+export * from "./sessions/SessionResolverFactory";
+export * from "./sessions/sessionCookie";

package/src/sessions/InMemorySessionResolver.ts

@@ -0,0 +1,20 @@
+import {ResolvedSession, SessionResolver} from "anbaric-tsapi";
+
+/* A resolver backed by a seeded token->session map, for local runs and tests.
+   Empty by default, so an unknown token resolves to undefined. */
+class InMemorySessionResolver implements SessionResolver {
+
+    private sessions = new Map<string, ResolvedSession>();
+
+    seed(sessionToken : string, session : ResolvedSession) : this {
+        this.sessions.set(sessionToken, session);
+        return this;
+    }
+
+    async resolve(sessionToken : string) : Promise<ResolvedSession | undefined> {
+        return this.sessions.get(sessionToken);
+    }
+
+}
+
+export { InMemorySessionResolver }

package/src/sessions/SessionResolverFactory.ts

@@ -0,0 +1,16 @@
+import {SessionResolver} from "anbaric-tsapi";
+import {CloudSessionResolver} from "anbaric-impl-cloud";
+import {InMemorySessionResolver} from "./InMemorySessionResolver";
+
+const SessionResolverFactory = {
+    instance() : SessionResolver {
+        switch (process.env.ANBARIC_SESSION_RESOLVER_TYPE) {
+            case "cloud":
+                return new CloudSessionResolver();
+            default:
+                return new InMemorySessionResolver();
+        }
+    }
+}
+
+export { SessionResolverFactory };

package/src/sessions/sessionCookie.ts

@@ -0,0 +1,16 @@
+import {IncomingMessage} from "node:http";
+
+const SESSION_COOKIE = "anbaric_session";
+
+/* Reads the anbaric_session cookie value from an incoming request (or a raw
+   Cookie header string). Returns undefined when the cookie is absent. */
+const sessionCookie = (source : IncomingMessage | string) : string | undefined => {
+    const header = typeof source === "string" ? source : String(source.headers.cookie ?? "");
+    for (const cookie of header.split(";")) {
+        const [name, ...value] = cookie.trim().split("=");
+        if (name === SESSION_COOKIE) return value.join("=");
+    }
+    return undefined;
+};
+
+export { sessionCookie, SESSION_COOKIE }