anbaric-cloud-hosting 1.18.1 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anbaric-cloud-hosting",
-  "version": "1.18.1",
+  "version": "1.20.0",
   "description": "Anbaric Cloud hosting service: Postgres-backed job persistence and queuing exposed over an HTTP API",
   "license": "MIT",
   "author": "chris@anbaric.ai",
@@ -18,17 +18,17 @@
     "@aws-sdk/client-s3": "^3.1110.0",
     "@aws-sdk/client-secrets-manager": "^3.700.0",
     "@aws-sdk/client-servicediscovery": "^3.1110.0",
-    "anbaric-data-store": "^1.18.1",
-    "anbaric-plugins": "^1.18.1",
-    "anbaric-tsapi": "^1.18.1",
+    "anbaric-data-store": "^1.20.0",
+    "anbaric-plugins": "^1.20.0",
+    "anbaric-tsapi": "^1.20.0",
     "esbuild": "^0.28.2",
     "pg": "^8.16.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/pg": "^8.15.0",
-    "anbaric-impl-cloud": "^1.18.1",
-    "anbaric-state-machine": "^1.18.1",
+    "anbaric-impl-cloud": "^1.20.0",
+    "anbaric-state-machine": "^1.20.0",
     "tsx": "^4.20.0",
     "typescript": "^7.0.2"
   },

package/src/app-management/DockerBuildLayer.ts

@@ -89,6 +89,7 @@ class DockerBuildLayer extends BaseBuildLayer {
             "--env", "ANBARIC_JSON_STORE_TYPE=cloud",
             "--env", "ANBARIC_SECRET_STORE_TYPE=cloud",
             "--env", "ANBARIC_AUDITOR_TYPE=cloud",
+            "--env", "ANBARIC_SESSION_RESOLVER_TYPE=cloud",
             "--env", `ANBARIC_CONSUMER_PORT=${deployment.consumerPort}`,
             "--env", `ANBARIC_CONSUMER_URL=http://${container}:${deployment.consumerPort}`,
             ...sqlEnv,

package/src/app-management/FargateBuildLayer.ts

@@ -178,6 +178,7 @@ class FargateBuildLayer extends BaseBuildLayer {
                     { name: "ANBARIC_JSON_STORE_TYPE", value: "cloud" },
                     { name: "ANBARIC_SECRET_STORE_TYPE", value: "cloud" },
                     { name: "ANBARIC_AUDITOR_TYPE", value: "cloud" },
+                    { name: "ANBARIC_SESSION_RESOLVER_TYPE", value: "cloud" },
                     { name: "ANBARIC_CONSUMER_PORT", value: String(deployment.consumerPort) },
                     { name: "ANBARIC_CONSUMER_URL", value: `http://${deployment.appHost}:${deployment.consumerPort}` },
                     ...(this.options.servicesUrl ? [{ name: "ANBARIC_SERVICES_URL", value: this.options.servicesUrl }] : []),

package/src/data-store/PostgresAuditRecordStore.ts

@@ -4,7 +4,7 @@ import {AuditFilter, AuditRecordStore} from "../auditing/AuditRecordStore";
 
 /* The writes worth keeping in the durable trail; reads (READ, LIST, QUERY) are
    dropped by default. Interactions are plain strings chosen by each store. */
-const DEFAULT_WRITE_MASK : Array<string> = ["INITIALIZE", "CREATE", "SAVE", "UPDATE_PROPERTIES", "CHANGE_STATE", "DELETE", "EXECUTE", "KILL"];
+const DEFAULT_WRITE_MASK : Array<string> = ["INITIALIZE", "CREATE", "SAVE", "UPDATE_PROPERTIES", "CHANGE_STATE", "AWAIT", "DELETE", "EXECUTE", "KILL"];
 
 /* Persists audit records, subject to a write mask: only the interactions in
    the mask are stored, so high-volume reads can be audited at the call site

package/src/data-store/PostgresJobPersistence.ts

@@ -1,4 +1,4 @@
-import {Auditor, Job, JobPersistence, NoOpAuditor, deserializeJob} from "anbaric-tsapi";
+import {Auditor, Job, JobPersistence, NoOpAuditor, SerializedWaitForInput, deserializeJob, serializeWaitForInput} from "anbaric-tsapi";
 import {Pool} from "pg";
 
 type JobRow = {
@@ -10,9 +10,18 @@ type JobRow = {
     started_by : string,
     last_updated : Date,
     killed : boolean,
+    status : string,
+    waiting_for? : string,
+    await_metadata? : SerializedWaitForInput,
 };
 
-const JOB_COLUMNS = "id, state, properties, workflow_id, started_at, started_by, last_updated, killed";
+/* The await a job is parked on is normalised into the awaits table: jobs
+   carry a waiting_for foreign key, the metadata lives once in awaits, and the
+   job's awaitMetadata is rejoined on read. */
+const JOB_SELECT =
+    `SELECT j.id, j.state, j.properties, j.workflow_id, j.started_at, j.started_by, j.last_updated,
+            j.killed, j.status, j.waiting_for, a.metadata AS await_metadata
+     FROM jobs j LEFT JOIN awaits a ON a.id = j.waiting_for`;
 
 class PostgresJobPersistence extends JobPersistence {
 
@@ -21,21 +30,47 @@ class PostgresJobPersistence extends JobPersistence {
     }
 
     protected async saveInternal(job : Job) : Promise<void> {
-        await this.pool.query(
-            `INSERT INTO jobs (id, state, properties, workflow_id, started_at, started_by, last_updated, killed)
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-             ON CONFLICT (id) DO UPDATE SET state = EXCLUDED.state, properties = EXCLUDED.properties,
-                 workflow_id = EXCLUDED.workflow_id, last_updated = EXCLUDED.last_updated, killed = EXCLUDED.killed`,
-            [job.id, job.state, Object.fromEntries(job.properties), job.workflowId,
-                job.startedAt, job.startedBy, job.lastUpdated, job.killed],
-        );
+        const client = await this.pool.connect();
+        try {
+            await client.query("BEGIN");
+
+            const previous = await client.query("SELECT waiting_for FROM jobs WHERE id = $1", [job.id]);
+            const previousAwait : string | null = previous.rows[0]?.waiting_for ?? null;
+
+            if (job.waitingFor) {
+                await client.query(
+                    `INSERT INTO awaits (id, metadata) VALUES ($1, $2)
+                     ON CONFLICT (id) DO UPDATE SET metadata = EXCLUDED.metadata`,
+                    [job.waitingFor, job.awaitMetadata ? serializeWaitForInput(job.awaitMetadata) : {}],
+                );
+            }
+
+            await client.query(
+                `INSERT INTO jobs (id, state, properties, workflow_id, started_at, started_by, last_updated, killed, status, waiting_for)
+                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+                 ON CONFLICT (id) DO UPDATE SET state = EXCLUDED.state, properties = EXCLUDED.properties,
+                     workflow_id = EXCLUDED.workflow_id, last_updated = EXCLUDED.last_updated, killed = EXCLUDED.killed,
+                     status = EXCLUDED.status, waiting_for = EXCLUDED.waiting_for`,
+                [job.id, job.state, Object.fromEntries(job.properties), job.workflowId,
+                    job.startedAt, job.startedBy, job.lastUpdated, job.killed, job.status, job.waitingFor ?? null],
+            );
+
+            // The await the job has left is no longer referenced - drop its metadata.
+            if (previousAwait && previousAwait !== job.waitingFor) {
+                await client.query("DELETE FROM awaits WHERE id = $1", [previousAwait]);
+            }
+
+            await client.query("COMMIT");
+        } catch (error) {
+            await client.query("ROLLBACK");
+            throw error;
+        } finally {
+            client.release();
+        }
     }
 
     protected async retrieveInternal(id : string) : Promise<Job> {
-        const result = await this.pool.query(
-            `SELECT ${JOB_COLUMNS} FROM jobs WHERE id = $1`,
-            [id],
-        );
+        const result = await this.pool.query(`${JOB_SELECT} WHERE j.id = $1`, [id]);
         if (result.rowCount === 0) throw new Error(`No job found with id "${id}"`);
 
         return this.deserializeRow(result.rows[0]);
@@ -47,7 +82,7 @@ class PostgresJobPersistence extends JobPersistence {
 
     protected async listInternal(pageSize : number = 100, page : number = 0) : Promise<Array<Job>> {
         const result = await this.pool.query(
-            `SELECT ${JOB_COLUMNS} FROM jobs ORDER BY inserted_at LIMIT $1 OFFSET $2`,
+            `${JOB_SELECT} ORDER BY j.inserted_at LIMIT $1 OFFSET $2`,
             [pageSize, page * pageSize],
         );
 
@@ -81,6 +116,9 @@ class PostgresJobPersistence extends JobPersistence {
             startedBy: row.started_by,
             lastUpdated: row.last_updated.toISOString(),
             killed: row.killed,
+            status: row.status,
+            waitingFor: row.waiting_for ?? undefined,
+            awaitMetadata: row.await_metadata ?? undefined,
         });
     }
 

package/src/data-store/Schema.ts

@@ -14,6 +14,7 @@ const ensureSchema = async (pool : Pool) : Promise<void> => {
             started_by   TEXT NOT NULL DEFAULT 'system',
             last_updated TIMESTAMPTZ NOT NULL DEFAULT now(),
             transitions  JSONB NOT NULL DEFAULT '[]',
+            status       TEXT NOT NULL DEFAULT 'active',
             inserted_at  BIGINT GENERATED ALWAYS AS IDENTITY
         )
     `);
@@ -23,6 +24,16 @@ const ensureSchema = async (pool : Pool) : Promise<void> => {
     await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS last_updated TIMESTAMPTZ NOT NULL DEFAULT now()");
     await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS transitions JSONB NOT NULL DEFAULT '[]'");
     await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS killed BOOLEAN NOT NULL DEFAULT false");
+    await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'active'");
+    // The await a job is parked on; its metadata is normalised here rather than on the job.
+    await pool.query(`
+        CREATE TABLE IF NOT EXISTS awaits (
+            id         UUID PRIMARY KEY,
+            metadata   JSONB NOT NULL DEFAULT '{}',
+            created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+        )
+    `);
+    await pool.query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS waiting_for UUID REFERENCES awaits(id) ON DELETE SET NULL");
     await pool.query(`
         CREATE TABLE IF NOT EXISTS documents (
             collection  TEXT NOT NULL,

package/src/hosting/HostingServer.ts

@@ -11,6 +11,7 @@ import {AppsHandler} from "./handlers/AppsHandler";
 import {AuditsHandler} from "./handlers/AuditsHandler";
 import {AuthorizeCliHandler} from "./handlers/auth/AuthorizeCliHandler";
 import {KeysHandler} from "./handlers/auth/KeysHandler";
+import {SessionsHandler} from "./handlers/auth/SessionsHandler";
 import {WhoamiHandler} from "./handlers/auth/WhoamiHandler";
 import {ConsumersHandler} from "./handlers/ConsumersHandler";
 import {DocumentsHandler} from "./handlers/DocumentsHandler";
@@ -60,12 +61,14 @@ class HostingServer {
         const documents = documentStoreFor && new DocumentsHandler(documentStoreFor);
         const secrets = secretStore && new SecretsHandler(secretStore);
         const audits = auditRecords && new AuditsHandler(auditRecords);
+        const sessions = new SessionsHandler();
 
         const publicRouter = new Router();
         publicRouter.registerRoot(pages);
         publicRouter.register("ping", ping);
         if (plugins.length > 0) publicRouter.registerApi("plugins", new PluginsHandler(plugins));
         publicRouter.registerApi("whoami", new WhoamiHandler());
+        publicRouter.registerApi("sessions", sessions);
         publicRouter.registerApi("jobs", jobs);
         publicRouter.registerApi("queue", queueHandler);
         publicRouter.registerApi("consumers", consumers);
@@ -84,6 +87,7 @@ class HostingServer {
 
         const internalRouter = new Router();
         internalRouter.register("ping", ping);
+        internalRouter.registerApi("sessions", sessions);
         internalRouter.registerApi("jobs", jobs);
         internalRouter.registerApi("queue", queueHandler);
         internalRouter.registerApi("consumers", consumers);
@@ -113,7 +117,7 @@ class HostingServer {
 
     async close() : Promise<void> {
         if (this.internalServer.listening) await this.internalServer.close();
-        await this.publicServer.close();
+        if (this.publicServer.listening) await this.publicServer.close();
     }
 
 }

package/src/hosting/handlers/auth/SessionsHandler.ts

@@ -0,0 +1,35 @@
+import {SessionSigner} from "../../../auth/SessionSigner";
+import {Request} from "../../Request";
+import {RequestHandler} from "../../RequestHandler";
+
+/* Resolves a platform session token into the user's identity, for apps that
+   cannot verify it themselves (the signing secret is platform only). The token
+   travels in the body - it is the credential - so this needs no session
+   middleware and is safe on the internal, app-facing router. */
+class SessionsHandler implements RequestHandler {
+
+    constructor(private sessionSigner : SessionSigner = new SessionSigner()) {}
+
+    async handle(request : Request) : Promise<void> {
+        if (request.method === "POST" && request.id === "resolve" && !request.subresource) {
+            return this.resolve(request);
+        }
+        request.notFound();
+    }
+
+    private async resolve(request : Request) : Promise<void> {
+        const body = await request.body() as { session? : string } | undefined;
+        const resolved = this.sessionSigner.verify(body?.session);
+        if (!resolved) return request.reply(401, { error: "Invalid or expired session" });
+
+        const [user, tenant] = resolved;
+        request.reply(200, {
+            id: user.id,
+            roles: user.roles.map(role => role.id),
+            tenant: tenant?.id,
+        });
+    }
+
+}
+
+export { SessionsHandler }