@hexis-ai/engram-server 0.11.3 → 0.13.0

package/dist/adapters/memory-key-store.d.ts

@@ -13,6 +13,10 @@ export declare class InMemoryKeyStore implements KeyStore {
     }): Promise<Workspace>;
     getWorkspace(id: string): Promise<Workspace | null>;
     listWorkspaces(): Promise<Workspace[]>;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Workspace>;
     deleteWorkspace(id: string): Promise<void>;
     issueKey(workspaceId: string, opts?: {
         name?: string;

package/dist/adapters/memory-key-store.js

@@ -26,6 +26,18 @@ export class InMemoryKeyStore {
     async listWorkspaces() {
         return [...this.workspaces.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
     }
+    async updateWorkspace(id, patch) {
+        const existing = this.workspaces.get(id);
+        if (!existing)
+            throw new Error("workspace_not_found");
+        const next = {
+            ...existing,
+            ...(patch.name !== undefined ? { name: patch.name } : {}),
+            ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+        };
+        this.workspaces.set(id, next);
+        return next;
+    }
     async deleteWorkspace(id) {
         this.workspaces.delete(id);
         for (const [keyId, row] of this.keys) {

package/dist/adapters/memory.js

@@ -1,11 +1,5 @@
-import { foldEvents } from "../storage";
-function defaultPersonId() {
-    const ALPHA = "abcdefghijklmnopqrstuvwxyz0123456789";
-    let out = "p_";
-    for (let i = 0; i < 8; i++)
-        out += ALPHA[Math.floor(Math.random() * ALPHA.length)];
-    return out;
-}
+import { foldEvents, newPersonId } from "../storage";
+import { applyPartial } from "./util";
 /**
  * In-process storage adapter for tests, dev, and small single-node deploys.
  * Idempotency: events keyed by (sessionId, seq) — duplicates overwrite by seq.
@@ -19,7 +13,7 @@ export class InMemoryAdapter {
     identities = new Map();
     newPersonId;
     constructor(opts = {}) {
-        this.newPersonId = opts.newPersonId ?? defaultPersonId;
+        this.newPersonId = opts.newPersonId ?? newPersonId;
     }
     // --- Sessions -----------------------------------------------------
     async createSession(init) {
@@ -88,49 +82,12 @@ export class InMemoryAdapter {
         const s = this.sessions.get(sessionId);
         if (!s)
             return null;
-        // Patch semantics: undefined = leave alone; null = clear; value = set.
-        // SessionRow optional fields use `string | undefined`, so a "null"
-        // request collapses to `undefined` storage-side.
-        const next = { ...s.row };
-        if (patch.title !== undefined) {
-            if (patch.title === null)
-                delete next.title;
-            else
-                next.title = patch.title;
-        }
-        if (patch.channel !== undefined) {
-            if (patch.channel === null)
-                delete next.channel;
-            else
-                next.channel = patch.channel;
-        }
-        if (patch.status !== undefined) {
-            next.status = patch.status;
-        }
-        if (patch.summary !== undefined) {
-            if (patch.summary === null)
-                delete next.summary;
-            else
-                next.summary = patch.summary;
-        }
-        if (patch.model !== undefined) {
-            if (patch.model === null)
-                delete next.model;
-            else
-                next.model = patch.model;
-        }
-        if (patch.trigger_conversation_id !== undefined) {
-            if (patch.trigger_conversation_id === null)
-                delete next.trigger_conversation_id;
-            else
-                next.trigger_conversation_id = patch.trigger_conversation_id;
-        }
-        if (patch.trigger_event_id !== undefined) {
-            if (patch.trigger_event_id === null)
-                delete next.trigger_event_id;
-            else
-                next.trigger_event_id = patch.trigger_event_id;
-        }
+        // Patch semantics: undefined = leave alone; null = clear (deletes the
+        // key, matching the SessionRow shape where optional fields are absent);
+        // value = set. `status` clears to "active" to match the column default.
+        const next = applyPartial(s.row, patch, {
+            status: "active",
+        });
         next.updatedAt = new Date().toISOString();
         s.row = next;
         return foldEvents(s.row, [...s.events.values()], new Date());
@@ -213,16 +170,15 @@ export class InMemoryAdapter {
         const existing = this.persons.get(id);
         if (!existing)
             return null;
-        const now = new Date().toISOString();
-        // undefined = no-op, null = clear (per the SDK contract).
-        const next = {
-            ...existing,
-            display_name: patch.display_name !== undefined ? patch.display_name : existing.display_name,
-            role: patch.role !== undefined ? patch.role : existing.role ?? null,
-            team: patch.team !== undefined ? patch.team : existing.team ?? null,
-            source: patch.source !== undefined ? patch.source : existing.source ?? "auto",
-            updated_at: now,
-        };
+        // undefined = no-op; null = clear (display_name/role/team to null,
+        // source to "auto" to match the column default).
+        const next = applyPartial(existing, patch, {
+            display_name: null,
+            role: null,
+            team: null,
+            source: "auto",
+        });
+        next.updated_at = new Date().toISOString();
         this.persons.set(id, next);
         return next;
     }
@@ -269,8 +225,18 @@ export class InMemoryAdapter {
     }
     // --- Aliases ------------------------------------------------------
     async upsertAlias(personId, input) {
-        if (!this.persons.has(personId))
-            return null;
+        if (!this.persons.has(personId)) {
+            const stubNow = new Date().toISOString();
+            this.persons.set(personId, {
+                id: personId,
+                display_name: null,
+                role: null,
+                team: null,
+                source: undefined,
+                created_at: stubNow,
+                updated_at: stubNow,
+            });
+        }
         const key = aliasKey(personId, input.name);
         const now = new Date().toISOString();
         const existing = this.aliases.get(key);
@@ -304,8 +270,23 @@ export class InMemoryAdapter {
     }
     // --- Identities ---------------------------------------------------
     async upsertIdentity(ref, input) {
-        if (!this.persons.has(input.person_id))
-            return null;
+        // Auto-create a stub person when missing. The two telemetry
+        // calls (person + identity) race over the network; treating
+        // the identity PUT as authoritative for "this person id exists"
+        // matches the host-supplied-id upsert model and avoids a 404
+        // when the calls arrive out of order.
+        if (!this.persons.has(input.person_id)) {
+            const stubNow = new Date().toISOString();
+            this.persons.set(input.person_id, {
+                id: input.person_id,
+                display_name: null,
+                role: null,
+                team: null,
+                source: undefined,
+                created_at: stubNow,
+                updated_at: stubNow,
+            });
+        }
         const now = new Date().toISOString();
         const existing = this.identities.get(ref);
         // COALESCE-on-conflict for the soft-overlap fields; ref-level

package/dist/adapters/pg-tagged.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tagged-template SQL client backed by node-postgres (`pg`).
+ *
+ * The rest of the codebase was written against the `postgres` package's
+ * tagged-template surface (`SqlClient` in ./postgres.ts). This adapter
+ * exposes the same shape on top of a `pg.Pool` (or `pg.PoolClient`) so
+ * we can unify on a single SQL driver — better-auth requires `pg`, and
+ * keeping two pools around just to satisfy `postgres-js`'s template API
+ * was preventing cross-store transactions.
+ *
+ * Translation rule: each `${value}` becomes `$N` in the emitted SQL,
+ * and the values land in the parameter array in tag order. Arrays
+ * map directly to Postgres arrays via `pg`'s native handling (callers
+ * already include explicit `::text[]` casts where needed).
+ */
+import type { Pool, PoolClient } from "pg";
+import type { SqlClient } from "./postgres";
+export declare function pgSqlClient(executor: Pool | PoolClient): SqlClient;

package/dist/adapters/pg-tagged.js

@@ -0,0 +1,29 @@
+/**
+ * Tagged-template SQL client backed by node-postgres (`pg`).
+ *
+ * The rest of the codebase was written against the `postgres` package's
+ * tagged-template surface (`SqlClient` in ./postgres.ts). This adapter
+ * exposes the same shape on top of a `pg.Pool` (or `pg.PoolClient`) so
+ * we can unify on a single SQL driver — better-auth requires `pg`, and
+ * keeping two pools around just to satisfy `postgres-js`'s template API
+ * was preventing cross-store transactions.
+ *
+ * Translation rule: each `${value}` becomes `$N` in the emitted SQL,
+ * and the values land in the parameter array in tag order. Arrays
+ * map directly to Postgres arrays via `pg`'s native handling (callers
+ * already include explicit `::text[]` casts where needed).
+ */
+export function pgSqlClient(executor) {
+    const tagged = (async (strings, ...values) => {
+        let text = strings[0];
+        for (let i = 0; i < values.length; i++) {
+            text += `$${i + 1}` + strings[i + 1];
+        }
+        const r = await executor.query({ text, values });
+        return r.rows;
+    });
+    tagged.unsafe = async (text) => {
+        await executor.query(text);
+    };
+    return tagged;
+}

package/dist/adapters/postgres-key-store.d.ts

@@ -15,6 +15,10 @@ export declare class PostgresKeyStore implements KeyStore {
     }): Promise<Workspace>;
     getWorkspace(id: string): Promise<Workspace | null>;
     listWorkspaces(): Promise<Workspace[]>;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Workspace>;
     deleteWorkspace(id: string): Promise<void>;
     issueKey(workspaceId: string, opts?: {
         name?: string;

package/dist/adapters/postgres-key-store.js

@@ -1,5 +1,6 @@
 import { deriveKey, hashKey, mintKey, resolveWorkspaceId, } from "../key-store";
 import { runMigrations } from "../migrator";
+import { isoString } from "./util";
 export class PostgresKeyStore {
     sql;
     constructor(sql) {
@@ -36,6 +37,19 @@ export class PostgresKeyStore {
     `;
         return rows.map(toWorkspace);
     }
+    async updateWorkspace(id, patch) {
+        const rows = await this.sql `
+      UPDATE engram_workspaces
+      SET
+        name = COALESCE(${patch.name ?? null}, name),
+        metadata = COALESCE(${patch.metadata ? patch.metadata : null}, metadata)
+      WHERE id = ${id}
+      RETURNING id, name, metadata, created_at
+    `;
+        if (rows.length === 0)
+            throw new Error("workspace_not_found");
+        return toWorkspace(rows[0]);
+    }
     async deleteWorkspace(id) {
         // engram_api_keys cascades via FK. engram_sessions/events are explicit
         // since they predate the workspaces table and have no FK to it.
@@ -132,6 +146,3 @@ function toInfo(r) {
         ...(r.revoked_at !== null ? { revokedAt: isoString(r.revoked_at) } : {}),
     };
 }
-function isoString(v) {
-    return typeof v === "string" ? v : v.toISOString();
-}

package/dist/adapters/postgres-org-store.d.ts

@@ -0,0 +1,42 @@
+import type { Pool } from "pg";
+import type { OrgMembershipRow, OrgRow, OrgStore } from "../org-store";
+export declare class PostgresOrgStore implements OrgStore {
+    private readonly pool;
+    constructor(pool: Pool);
+    createOrg(input: {
+        id?: string;
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<OrgRow>;
+    getOrg(id: string): Promise<OrgRow | null>;
+    listOrgs(): Promise<OrgRow[]>;
+    updateOrg(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<OrgRow>;
+    deleteOrg(id: string): Promise<void>;
+    listMembers(orgId: string): Promise<OrgMembershipRow[]>;
+    upsertMember(input: {
+        orgId: string;
+        userId: string;
+        role?: string;
+    }): Promise<OrgMembershipRow>;
+    removeMember(orgId: string, userId: string): Promise<void>;
+    findUserByEmail(email: string): Promise<{
+        id: string;
+        email: string;
+    } | null>;
+    listOrgsForUser(userId: string): Promise<OrgMembershipRow[]>;
+    setWorkspaceOrg(workspaceId: string, orgId: string): Promise<void>;
+    listWorkspacesForOrg(orgId: string): Promise<{
+        id: string;
+        name: string | null;
+    }[]>;
+    listWorkspacesForUser(userId: string): Promise<{
+        id: string;
+        name: string | null;
+        orgId: string;
+    }[]>;
+    userCanAccessWorkspace(userId: string, workspaceId: string): Promise<boolean>;
+    workspaceInOrg(orgId: string, workspaceId: string): Promise<boolean>;
+}

package/dist/adapters/postgres-org-store.js

@@ -0,0 +1,120 @@
+import { randomUUID } from "node:crypto";
+import { isoString } from "./util";
+function toOrg(r) {
+    return {
+        id: r.id,
+        name: r.name,
+        metadata: r.metadata ?? {},
+        createdAt: isoString(r.created_at),
+    };
+}
+function toMember(r) {
+    return {
+        orgId: r.org_id,
+        userId: r.user_id,
+        role: r.role,
+        joinedAt: isoString(r.joined_at),
+    };
+}
+export class PostgresOrgStore {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    // ---------- orgs ---------------------------------------------
+    async createOrg(input) {
+        const id = input.id ?? `org_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+        const { rows } = await this.pool.query(`INSERT INTO engram_orgs (id, name, metadata)
+       VALUES ($1, $2, $3::jsonb)
+       ON CONFLICT (id) DO NOTHING
+       RETURNING id, name, metadata, created_at`, [id, input.name ?? null, JSON.stringify(input.metadata ?? {})]);
+        if (rows[0])
+            return toOrg(rows[0]);
+        const existing = await this.getOrg(id);
+        if (!existing)
+            throw new Error("org_create_failed");
+        return existing;
+    }
+    async getOrg(id) {
+        const { rows } = await this.pool.query(`SELECT id, name, metadata, created_at FROM engram_orgs WHERE id = $1`, [id]);
+        return rows[0] ? toOrg(rows[0]) : null;
+    }
+    async listOrgs() {
+        const { rows } = await this.pool.query(`SELECT id, name, metadata, created_at FROM engram_orgs ORDER BY created_at`);
+        return rows.map(toOrg);
+    }
+    async updateOrg(id, patch) {
+        const { rows } = await this.pool.query(`UPDATE engram_orgs
+       SET
+         name = COALESCE($2, name),
+         metadata = COALESCE($3::jsonb, metadata)
+       WHERE id = $1
+       RETURNING id, name, metadata, created_at`, [
+            id,
+            patch.name ?? null,
+            patch.metadata ? JSON.stringify(patch.metadata) : null,
+        ]);
+        if (rows.length === 0)
+            throw new Error("org_not_found");
+        return toOrg(rows[0]);
+    }
+    async deleteOrg(id) {
+        // CASCADE drops members + workspaces under this org.
+        await this.pool.query(`DELETE FROM engram_orgs WHERE id = $1`, [id]);
+    }
+    // ---------- members ------------------------------------------
+    async listMembers(orgId) {
+        const { rows } = await this.pool.query(`SELECT org_id, user_id, role, joined_at
+       FROM engram_org_members WHERE org_id = $1 ORDER BY joined_at`, [orgId]);
+        return rows.map(toMember);
+    }
+    async upsertMember(input) {
+        const role = input.role ?? "member";
+        const { rows } = await this.pool.query(`INSERT INTO engram_org_members (org_id, user_id, role)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (org_id, user_id) DO UPDATE SET role = EXCLUDED.role
+       RETURNING org_id, user_id, role, joined_at`, [input.orgId, input.userId, role]);
+        return toMember(rows[0]);
+    }
+    async removeMember(orgId, userId) {
+        await this.pool.query(`DELETE FROM engram_org_members WHERE org_id = $1 AND user_id = $2`, [orgId, userId]);
+    }
+    async findUserByEmail(email) {
+        const { rows } = await this.pool.query(`SELECT id, email FROM engram_auth_users WHERE LOWER(email) = LOWER($1) LIMIT 1`, [email]);
+        return rows[0] ?? null;
+    }
+    async listOrgsForUser(userId) {
+        const { rows } = await this.pool.query(`SELECT org_id, user_id, role, joined_at
+       FROM engram_org_members WHERE user_id = $1 ORDER BY joined_at`, [userId]);
+        return rows.map(toMember);
+    }
+    // ---------- workspace ↔ org link -----------------------------
+    async setWorkspaceOrg(workspaceId, orgId) {
+        await this.pool.query(`UPDATE engram_workspaces SET org_id = $1 WHERE id = $2`, [orgId, workspaceId]);
+    }
+    async listWorkspacesForOrg(orgId) {
+        const { rows } = await this.pool.query(`SELECT id, name FROM engram_workspaces WHERE org_id = $1 ORDER BY created_at`, [orgId]);
+        return rows;
+    }
+    async listWorkspacesForUser(userId) {
+        const { rows } = await this.pool.query(`SELECT w.id, w.name, w.org_id
+       FROM engram_workspaces w
+       JOIN engram_org_members m ON m.org_id = w.org_id
+       WHERE m.user_id = $1
+       ORDER BY w.created_at`, [userId]);
+        return rows.map((r) => ({ id: r.id, name: r.name, orgId: r.org_id }));
+    }
+    async userCanAccessWorkspace(userId, workspaceId) {
+        const { rows } = await this.pool.query(`SELECT 1 AS ok
+       FROM engram_workspaces w
+       JOIN engram_org_members m ON m.org_id = w.org_id
+       WHERE m.user_id = $1 AND w.id = $2
+       LIMIT 1`, [userId, workspaceId]);
+        return rows.length > 0;
+    }
+    async workspaceInOrg(orgId, workspaceId) {
+        const { rows } = await this.pool.query(`SELECT 1 AS ok FROM engram_workspaces
+       WHERE id = $1 AND org_id = $2 LIMIT 1`, [workspaceId, orgId]);
+        return rows.length > 0;
+    }
+}