@axiom-lattice/pg-stores 2.0.10 → 3.0.1

package/src/migrations/add_project_kind_column.ts

@@ -0,0 +1,29 @@
+/**
+ * Migration: Add kind column to lattice_projects
+ *
+ * Adds a TEXT `kind` column (NOT NULL DEFAULT 'business') to the
+ * `lattice_projects` table for project classification
+ * ('business' | 'training' | 'personal'). Existing rows are backfilled
+ * with 'business' via the column default.
+ */
+
+import { PoolClient } from "pg";
+import { Migration } from "./migration";
+
+/** Adds kind TEXT column to lattice_projects */
+export const addProjectKindColumn: Migration = {
+  version: 165,
+  name: "add_project_kind_column",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_projects
+      ADD COLUMN IF NOT EXISTS kind TEXT NOT NULL DEFAULT 'business'
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_projects
+      DROP COLUMN IF EXISTS kind
+    `);
+  },
+};

package/src/migrations/agent_web_apps_migration.ts

@@ -0,0 +1,37 @@
+import type { PoolClient } from "pg";
+
+import type { Migration } from "./migration";
+
+export const createAgentWebAppsTable: Migration = {
+  version: 169,
+  name: "create_agent_web_apps_table",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_agent_web_apps (
+        id VARCHAR(255) PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        assistant_id VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        status VARCHAR(32) NOT NULL DEFAULT 'draft'
+          CONSTRAINT chk_lattice_agent_web_apps_status CHECK (status IN ('draft', 'active', 'disabled')),
+        integration JSONB NOT NULL,
+        scope JSONB NOT NULL,
+        features JSONB NOT NULL,
+        appearance JSONB NOT NULL DEFAULT '{}'::jsonb,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT date_trunc('milliseconds', NOW()),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT date_trunc('milliseconds', NOW())
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_web_apps_tenant_assistant
+      ON lattice_agent_web_apps(tenant_id, assistant_id)
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_lattice_agent_web_apps_tenant_assistant",
+    );
+    await client.query("DROP TABLE IF EXISTS lattice_agent_web_apps");
+  },
+};

package/src/migrations/task_work_items_migration.ts

@@ -49,3 +49,18 @@ export const addWorkItemProjectFieldsMigration: Migration = {
     `);
   },
 };
+
+export const addTaskWorkItemEventKeyMigration: Migration = {
+  version: 168,
+  name: "add_task_work_item_event_key",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_task_work_items
+        ADD COLUMN IF NOT EXISTS event_key TEXT
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_task_work_items_event_key
+        ON lattice_task_work_items (tenant_id, task_id, event_key) WHERE event_key IS NOT NULL
+    `);
+  },
+};

package/src/stores/PostgreSQLA2AApiKeyStore.ts

@@ -8,6 +8,7 @@ import type {
 } from "@axiom-lattice/protocols";
 import { MigrationManager } from "../migrations/migration";
 import { createA2AApiKeysTable } from "../migrations/a2a_api_key_migration";
+import { addA2AKeyAssistantIds } from "../migrations/add_a2a_key_assistant_ids";
 import { encrypt, decrypt } from "@axiom-lattice/core";
 import { randomUUID } from "crypto";
 
@@ -21,8 +22,8 @@ type KeyRow = {
   id: string;
   key_value: string;
   tenant_id: string;
-  project_id: string | null;
-  workspace_id: string | null;
+  project_id: string;
+  assistant_ids: string[] | null;
   label: string | null;
   enabled: boolean;
   created_at: Date;
@@ -38,8 +39,8 @@ function mapRowToRecord(row: KeyRow): A2AApiKeyRecord {
     id: row.id,
     key: decrypt(row.key_value),
     tenantId: row.tenant_id,
-    projectId: row.project_id || undefined,
-    workspaceId: row.workspace_id || undefined,
+    projectId: row.project_id,
+    assistantIds: row.assistant_ids ?? undefined,
     label: row.label || undefined,
     enabled: row.enabled,
     createdAt: row.created_at,
@@ -71,7 +72,12 @@ export class PostgreSQLA2AApiKeyStore implements A2AApiKeyStore {
           : (() => { throw new Error("Either pool or poolConfig must be provided"); })();
 
     this.migrationManager = new MigrationManager(this.pool);
+    // Standalone deployments (own poolConfig) must apply every migration the
+    // queries below depend on. `createPgStoreConfig` registers the same
+    // migrations on its own MigrationManager; managers dedupe by name, so the
+    // overlap is safe.
     this.migrationManager.register(createA2AApiKeysTable);
+    this.migrationManager.register(addA2AKeyAssistantIds);
 
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
@@ -116,6 +122,15 @@ export class PostgreSQLA2AApiKeyStore implements A2AApiKeyStore {
     return null;
   }
 
+  async findById(id: string): Promise<A2AApiKeyRecord | null> {
+    await this.ensureInitialized();
+    const result = await this.pool.query<KeyRow>(
+      `SELECT * FROM lattice_a2a_api_keys WHERE id = $1`,
+      [id],
+    );
+    return result.rows[0] ? mapRowToRecord(result.rows[0]) : null;
+  }
+
   async list(params: { tenantId?: string; limit?: number; offset?: number }): Promise<A2AApiKeyRecord[]> {
     await this.ensureInitialized();
     const limit = params.limit || 100;
@@ -138,9 +153,9 @@ export class PostgreSQLA2AApiKeyStore implements A2AApiKeyStore {
     await this.ensureInitialized();
     const key = generateApiKey();
     const result = await this.pool.query<KeyRow>(
-      `INSERT INTO lattice_a2a_api_keys (key_value, tenant_id, project_id, workspace_id, label)
+      `INSERT INTO lattice_a2a_api_keys (key_value, tenant_id, project_id, assistant_ids, label)
        VALUES ($1, $2, $3, $4, $5) RETURNING *`,
-      [encrypt(key), input.tenantId, input.projectId || null, input.workspaceId || null, input.label || null],
+      [encrypt(key), input.tenantId, input.projectId, input.assistantIds ? JSON.stringify(input.assistantIds) : null, input.label || null],
     );
     const record = mapRowToRecord(result.rows[0]);
     record.key = key;
@@ -196,8 +211,8 @@ export class PostgreSQLA2AApiKeyStore implements A2AApiKeyStore {
       map.set(key, {
         key,
         tenantId: row.tenant_id,
-        projectId: row.project_id || undefined,
-        workspaceId: row.workspace_id || undefined,
+        projectId: row.project_id,
+        assistantIds: row.assistant_ids ?? undefined,
       });
     }
     return map;

package/src/stores/PostgreSQLAgentWebAppStore.ts

@@ -0,0 +1,280 @@
+import { randomUUID } from "crypto";
+import type {
+  AgentWebApp,
+  AgentWebAppAppearance,
+  AgentWebAppFeatures,
+  AgentWebAppScope,
+  AgentWebAppStatus,
+  AgentWebAppStore,
+  AgentWebAppStorePatch,
+  AgentWebAppUpdateOptions,
+  CreateAgentWebAppInput,
+} from "@axiom-lattice/protocols";
+import { Pool } from "pg";
+import type { PoolConfig } from "pg";
+
+import { createAgentWebAppsTable } from "../migrations/agent_web_apps_migration";
+import { MigrationManager } from "../migrations/migration";
+
+export interface PostgreSQLAgentWebAppStoreOptions {
+  pool?: Pool;
+  poolConfig?: string | PoolConfig;
+  autoMigrate?: boolean;
+}
+
+type AgentWebAppRow = {
+  id: string;
+  tenant_id: string;
+  assistant_id: string;
+  name: string;
+  description: string | null;
+  status: AgentWebAppStatus;
+  integration: unknown;
+  scope: unknown;
+  features: unknown;
+  appearance: unknown;
+  created_at: Date;
+  updated_at: Date;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isIntegration(value: unknown): value is AgentWebApp["integration"] {
+  return isRecord(value) && value.type === "react_sdk";
+}
+
+function isScope(value: unknown): value is AgentWebAppScope {
+  return isRecord(value)
+    && typeof value.defaultProjectId === "string"
+    && isStringArray(value.allowedProjectIds)
+    && (value.defaultModelKey === undefined || typeof value.defaultModelKey === "string")
+    && (value.allowedModelKeys === undefined || isStringArray(value.allowedModelKeys));
+}
+
+function isFeatures(value: unknown): value is AgentWebAppFeatures {
+  return isRecord(value)
+    && typeof value.projectSelector === "boolean"
+    && typeof value.modelSelector === "boolean"
+    && typeof value.threadManagement === "boolean"
+    && typeof value.attachments === "boolean"
+    && typeof value.hitl === "boolean"
+    && typeof value.genUI === "boolean";
+}
+
+function isAppearance(value: unknown): value is AgentWebAppAppearance {
+  return isRecord(value)
+    && (value.title === undefined || typeof value.title === "string")
+    && (value.welcomeMessage === undefined || typeof value.welcomeMessage === "string")
+    && (value.primaryColor === undefined || typeof value.primaryColor === "string");
+}
+
+function isStatus(value: unknown): value is AgentWebAppStatus {
+  return value === "draft" || value === "active" || value === "disabled";
+}
+
+function mapRow(row: AgentWebAppRow): AgentWebApp {
+  if (
+    !isStatus(row.status)
+    || !isIntegration(row.integration)
+    || !isScope(row.scope)
+    || !isFeatures(row.features)
+    || !isAppearance(row.appearance)
+  ) {
+    throw new Error(`Invalid agent web app row: ${row.id}`);
+  }
+
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    name: row.name,
+    description: row.description ?? undefined,
+    status: row.status,
+    integration: row.integration,
+    scope: row.scope,
+    features: row.features,
+    appearance: row.appearance,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export class PostgreSQLAgentWebAppStore implements AgentWebAppStore {
+  private pool: Pool;
+  private migrationManager!: MigrationManager;
+  private initialized = false;
+  private ownsPool = true;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(options: PostgreSQLAgentWebAppStoreOptions) {
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
+    this.pool = typeof options.poolConfig === "string"
+      ? new Pool({ connectionString: options.poolConfig })
+      : options.poolConfig
+        ? new Pool(options.poolConfig)
+        : (() => { throw new Error("Either pool or poolConfig must be provided"); })();
+
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createAgentWebAppsTable);
+
+    if (options.autoMigrate !== false) {
+      this.startInitialization();
+    }
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    return this.startInitialization();
+  }
+
+  private startInitialization(): Promise<void> {
+    this.initPromise = this.migrationManager.migrate().then(() => {
+      this.initialized = true;
+    });
+    // Eager migration errors remain on initPromise for initialize/operations.
+    void this.initPromise.catch(() => undefined);
+    return this.initPromise;
+  }
+
+  async dispose(): Promise<void> {
+    if (this.ownsPool) await this.pool.end();
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) await this.initialize();
+  }
+
+  async list(tenantId: string, assistantId?: string): Promise<AgentWebApp[]> {
+    await this.ensureInitialized();
+    const result = assistantId === undefined
+      ? await this.pool.query<AgentWebAppRow>(
+        `SELECT * FROM lattice_agent_web_apps
+         WHERE tenant_id = $1
+         ORDER BY created_at DESC, id DESC`,
+        [tenantId],
+      )
+      : await this.pool.query<AgentWebAppRow>(
+        `SELECT * FROM lattice_agent_web_apps
+         WHERE tenant_id = $1 AND assistant_id = $2
+         ORDER BY created_at DESC, id DESC`,
+        [tenantId, assistantId],
+      );
+    return result.rows.map(mapRow);
+  }
+
+  async getById(tenantId: string, webAppId: string): Promise<AgentWebApp | null> {
+    await this.ensureInitialized();
+    const result = await this.pool.query<AgentWebAppRow>(
+      `SELECT * FROM lattice_agent_web_apps
+       WHERE tenant_id = $1 AND id = $2`,
+      [tenantId, webAppId],
+    );
+    return result.rows[0] ? mapRow(result.rows[0]) : null;
+  }
+
+  async findById(webAppId: string): Promise<AgentWebApp | null> {
+    await this.ensureInitialized();
+    const result = await this.pool.query<AgentWebAppRow>(
+      `SELECT * FROM lattice_agent_web_apps
+       WHERE id = $1`,
+      [webAppId],
+    );
+    return result.rows[0] ? mapRow(result.rows[0]) : null;
+  }
+
+  async create(tenantId: string, input: CreateAgentWebAppInput): Promise<AgentWebApp> {
+    await this.ensureInitialized();
+    const id = `webapp_${randomUUID().replace(/-/g, "")}`;
+    const result = await this.pool.query<AgentWebAppRow>(
+      `INSERT INTO lattice_agent_web_apps
+       (id, tenant_id, assistant_id, name, description, status, integration, scope, features, appearance)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8::jsonb, $9::jsonb, $10::jsonb)
+       RETURNING *`,
+      [
+        id,
+        tenantId,
+        input.assistantId,
+        input.name,
+        input.description ?? null,
+        "draft",
+        JSON.stringify(input.integration),
+        JSON.stringify(input.scope),
+        JSON.stringify(input.features),
+        JSON.stringify(input.appearance),
+      ],
+    );
+    return mapRow(result.rows[0]);
+  }
+
+  async update(
+    tenantId: string,
+    webAppId: string,
+    patch: AgentWebAppStorePatch,
+    options?: AgentWebAppUpdateOptions,
+  ): Promise<AgentWebApp | null> {
+    await this.ensureInitialized();
+    const assignments: string[] = [];
+    const values: unknown[] = [];
+    const add = (column: string, value: unknown): void => {
+      values.push(value);
+      assignments.push(`${column} = $${values.length}`);
+    };
+
+    if (patch.name !== undefined) add("name", patch.name);
+    if (Object.prototype.hasOwnProperty.call(patch, "description")) {
+      add("description", patch.description ?? null);
+    }
+    if (patch.scope !== undefined) {
+      add("scope", JSON.stringify(patch.scope));
+    }
+    if (patch.features !== undefined) {
+      add("features", JSON.stringify(patch.features));
+    }
+    if (patch.appearance !== undefined) {
+      add("appearance", JSON.stringify(patch.appearance));
+    }
+    if (patch.status !== undefined) add("status", patch.status);
+
+    if (assignments.length === 0) return this.getById(tenantId, webAppId);
+    values.push(tenantId, webAppId);
+    const tenantParam = values.length - 1;
+    const idParam = values.length;
+    const expectedUpdatedAtClause = options?.expectedUpdatedAt
+      ? ` AND date_trunc('milliseconds', updated_at) = $${values.push(options.expectedUpdatedAt)}`
+      : "";
+    const result = await this.pool.query<AgentWebAppRow>(
+      `UPDATE lattice_agent_web_apps
+       SET ${assignments.join(", ")}, updated_at = GREATEST(
+         date_trunc('milliseconds', clock_timestamp()),
+         updated_at + interval '1 millisecond'
+       )
+       WHERE tenant_id = $${tenantParam} AND id = $${idParam}${expectedUpdatedAtClause}
+       RETURNING *`,
+      values,
+    );
+    return result.rows[0] ? mapRow(result.rows[0]) : null;
+  }
+
+  async delete(tenantId: string, webAppId: string): Promise<boolean> {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_agent_web_apps
+       WHERE tenant_id = $1 AND id = $2`,
+      [tenantId, webAppId],
+    );
+    return result.rowCount === 1;
+  }
+}

package/src/stores/PostgreSQLProjectStore.ts

@@ -7,6 +7,7 @@ import type { PoolConfig } from "pg";
 import {
   ProjectStore,
   Project,
+  ProjectFilter,
   CreateProjectRequest,
   UpdateProjectRequest,
 } from "@axiom-lattice/protocols";
@@ -14,6 +15,7 @@ import { MigrationManager } from "../migrations/migration";
 import { createProjectsTable } from "../migrations/project_migrations";
 import { addProjectConfigColumn } from "../migrations/add_project_config_column";
 import { dropProjectFolderPathColumn } from "../migrations/drop_project_folder_path";
+import { addProjectKindColumn } from "../migrations/add_project_kind_column";
 
 /**
  * PostgreSQL ProjectStore options
@@ -69,6 +71,7 @@ export class PostgreSQLProjectStore implements ProjectStore {
     this.migrationManager.register(createProjectsTable);
     this.migrationManager.register(addProjectConfigColumn);
     this.migrationManager.register(dropProjectFolderPathColumn);
+    this.migrationManager.register(addProjectKindColumn);
 
     // Auto-migrate by default
     if (options.autoMigrate !== false) {
@@ -120,6 +123,7 @@ export class PostgreSQLProjectStore implements ProjectStore {
     name: string;
     description: string | null;
     config: unknown | null;
+    kind: string | null;
     created_at: Date;
     updated_at: Date;
   }): Project {
@@ -130,6 +134,7 @@ export class PostgreSQLProjectStore implements ProjectStore {
       name: row.name,
       description: row.description || undefined,
       config: row.config as Record<string, unknown> || undefined,
+      kind: (row.kind || "business") as Project["kind"],
       createdAt: row.created_at,
       updatedAt: row.updated_at,
     };
@@ -138,9 +143,17 @@ export class PostgreSQLProjectStore implements ProjectStore {
   /**
    * Get all projects for a specific workspace
    */
-  async getProjectsByWorkspace(tenantId: string, workspaceId: string): Promise<Project[]> {
+  async getProjectsByWorkspace(tenantId: string, workspaceId: string, filter?: ProjectFilter): Promise<Project[]> {
     await this.ensureInitialized();
 
+    const conditions = ["tenant_id = $1", "workspace_id = $2"];
+    const values: unknown[] = [tenantId, workspaceId];
+
+    if (filter?.kind !== undefined) {
+      values.push(filter.kind);
+      conditions.push(`kind = $${values.length}`);
+    }
+
     const result = await this.pool.query<{
       id: string;
       tenant_id: string;
@@ -148,16 +161,17 @@ export class PostgreSQLProjectStore implements ProjectStore {
       name: string;
       description: string | null;
       config: unknown | null;
+      kind: string | null;
       created_at: Date;
       updated_at: Date;
     }>(
       `
-      SELECT id, tenant_id, workspace_id, name, description, config, created_at, updated_at
+      SELECT id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at
       FROM lattice_projects
-      WHERE tenant_id = $1 AND workspace_id = $2
+      WHERE ${conditions.join(" AND ")}
       ORDER BY created_at DESC
     `,
-      [tenantId, workspaceId]
+      values
     );
 
     return result.rows.map(this.mapRowToProject);
@@ -176,11 +190,12 @@ export class PostgreSQLProjectStore implements ProjectStore {
       name: string;
       description: string | null;
       config: unknown | null;
+      kind: string | null;
       created_at: Date;
       updated_at: Date;
     }>(
       `
-      SELECT id, tenant_id, workspace_id, name, description, config, created_at, updated_at
+      SELECT id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at
       FROM lattice_projects
       WHERE id = $1 AND tenant_id = $2
     `,
@@ -206,19 +221,21 @@ export class PostgreSQLProjectStore implements ProjectStore {
     await this.ensureInitialized();
 
     const now = new Date();
+    const kind = data.kind || "business";
 
     await this.pool.query(
       `
-      INSERT INTO lattice_projects (id, tenant_id, workspace_id, name, description, config, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+      INSERT INTO lattice_projects (id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
       ON CONFLICT (id, tenant_id) DO UPDATE SET
         workspace_id = EXCLUDED.workspace_id,
         name = EXCLUDED.name,
         description = EXCLUDED.description,
         config = EXCLUDED.config,
+        kind = EXCLUDED.kind,
         updated_at = EXCLUDED.updated_at
     `,
-      [id, tenantId, workspaceId, data.name, data.description || null, data.config || null, now, now]
+      [id, tenantId, workspaceId, data.name, data.description || null, data.config || null, kind, now, now]
     );
 
     return {
@@ -228,6 +245,7 @@ export class PostgreSQLProjectStore implements ProjectStore {
       name: data.name,
       description: data.description,
       config: data.config,
+      kind,
       createdAt: now,
       updatedAt: now,
     };
@@ -273,6 +291,11 @@ export class PostgreSQLProjectStore implements ProjectStore {
       updateValues.push(updates.config || null);
     }
 
+    if (updates.kind !== undefined) {
+      updateFields.push(`kind = $${paramIndex++}`);
+      updateValues.push(updates.kind);
+    }
+
     if (updateFields.length === 0) {
       // No fields to update
       return existing;