@axiom-lattice/pg-stores 1.0.13 → 1.0.14

package/examples/database-config-store.example.ts

@@ -0,0 +1,178 @@
+/**
+ * DatabaseConfigStore 使用示例
+ * 
+ * 示例代码展示如何使用 DatabaseConfigStore 管理数据库配置
+ */
+
+// ============================================================================
+// 示例 1: 使用 InMemory 存储（默认）
+// ============================================================================
+
+import {
+  storeLatticeManager,
+  InMemoryDatabaseConfigStore,
+} from '@axiom-lattice/core';
+import type { DatabaseConfig } from '@axiom-lattice/protocols';
+
+async function exampleInMemory() {
+  // 获取默认的 InMemory Store
+  const store = await storeLatticeManager.getStoreLattice('default', 'database').store;
+  
+  const tenantId = 'tenant-123';
+  
+  // 创建数据库配置
+  const dbConfig: DatabaseConfig = {
+    type: 'postgres',
+    host: 'localhost',
+    port: 5432,
+    database: 'mydb',
+    user: 'admin',
+    password: 'secret123',  // 会自动加密存储（PG 实现）
+  };
+  
+  await store.createConfig(tenantId, 'config-1', {
+    key: 'main-db',
+    config: dbConfig,
+    name: 'Main Database',
+    description: 'Primary PostgreSQL database',
+  });
+  
+  // 获取配置
+  const config = await store.getConfigByKey(tenantId, 'main-db');
+  console.log('Database config:', config);
+  
+  // 获取所有配置
+  const allConfigs = await store.getAllConfigs(tenantId);
+  console.log('All configs:', allConfigs);
+}
+
+// ============================================================================
+// 示例 2: 使用 PostgreSQL 存储
+// ============================================================================
+
+import { PostgreSQLDatabaseConfigStore } from '@axiom-lattice/pg-stores';
+
+async function examplePostgreSQL() {
+  // 创建 PostgreSQL Store
+  const pgStore = new PostgreSQLDatabaseConfigStore({
+    poolConfig: process.env.DATABASE_URL || 'postgresql://localhost:5432/lattice',
+    autoMigrate: true,  // 自动运行迁移
+  });
+  
+  const tenantId = 'tenant-123';
+  
+  // 创建数据库配置
+  await pgStore.createConfig(tenantId, 'config-2', {
+    key: 'analytics-db',
+    config: {
+      type: 'postgres',
+      host: 'analytics.db',
+      port: 5432,
+      database: 'analytics',
+      user: 'analyst',
+      password: 'analytics-pass',
+      ssl: true,
+    },
+    name: 'Analytics Database',
+  });
+  
+  // 获取配置（密码会自动解密）
+  const config = await pgStore.getConfigByKey(tenantId, 'analytics-db');
+  console.log('Analytics DB password (decrypted):', config?.config.password);
+  
+  // 更新配置
+  await pgStore.updateConfig(tenantId, 'config-2', {
+    config: {
+      ...config!.config,
+      password: 'new-password',
+    },
+  });
+  
+  // 删除配置
+  await pgStore.deleteConfig(tenantId, 'config-2');
+  
+  // 清理资源
+  await pgStore.dispose();
+}
+
+// ============================================================================
+// 示例 3: 集成到 SqlDatabaseManager
+// ============================================================================
+
+import { sqlDatabaseManager } from '@axiom-lattice/core';
+
+async function exampleWithSqlManager() {
+  const store = await storeLatticeManager.getStoreLattice('default', 'database').store;
+  const tenantId = 'tenant-123';
+  
+  // 从 Store 加载所有数据库配置并注册到 SqlDatabaseManager
+  await sqlDatabaseManager.loadConfigsFromStore(store, tenantId);
+  
+  // 现在可以使用注册的数据库
+  const db = sqlDatabaseManager.getDatabase('main-db');
+  const tables = await db.listTables();
+  console.log('Tables:', tables);
+}
+
+// ============================================================================
+// 示例 4: 多租户场景
+// ============================================================================
+
+async function exampleMultiTenant() {
+  const store = await storeLatticeManager.getStoreLattice('default', 'database').store;
+  
+  // 为不同租户创建配置
+  await store.createConfig('tenant-a', 'config-1', {
+    key: 'db',
+    config: { type: 'postgres', database: 'db-a', user: 'user-a', password: 'pass-a' },
+  });
+  
+  await store.createConfig('tenant-b', 'config-1', {
+    key: 'db',
+    config: { type: 'postgres', database: 'db-b', user: 'user-b', password: 'pass-b' },
+  });
+  
+  // 获取租户 A 的配置
+  const tenantAConfigs = await store.getAllConfigs('tenant-a');
+  console.log('Tenant A configs:', tenantAConfigs);
+  
+  // 获取租户 B 的配置
+  const tenantBConfigs = await store.getAllConfigs('tenant-b');
+  console.log('Tenant B configs:', tenantBConfigs);
+}
+
+// ============================================================================
+// 示例 5: 环境变量配置
+// ============================================================================
+
+/**
+ * 设置加密密钥（生产环境必需）
+ * 
+ * 方法 1: 环境变量
+ * export LATTICE_ENCRYPTION_KEY="your-secret-key-at-least-32-characters"
+ * 
+ * 方法 2: 代码中设置（不推荐，仅用于测试）
+ * process.env.LATTICE_ENCRYPTION_KEY = 'your-secret-key';
+ * 
+ * 注意：
+ * - 密钥长度建议 32 字符以上
+ * - 生产环境必须设置，否则会有警告
+ * - 密钥丢失将导致无法解密已存储的密码
+ */
+
+// ============================================================================
+// 运行示例
+// ============================================================================
+
+async function main() {
+  try {
+    await exampleInMemory();
+    await examplePostgreSQL();
+    await exampleWithSqlManager();
+    await exampleMultiTenant();
+  } catch (error) {
+    console.error('Error running examples:', error);
+  }
+}
+
+// main();

package/examples/workspace-project-store.example.ts

@@ -0,0 +1,151 @@
+/**
+ * PostgreSQL Workspace and Project Store Example
+ * 
+ * Demonstrates how to use PostgreSQLWorkspaceStore and PostgreSQLProjectStore
+ */
+
+import {
+  PostgreSQLWorkspaceStore,
+  PostgreSQLProjectStore,
+} from "@axiom-lattice/pg-stores";
+import { storeLatticeManager } from "@axiom-lattice/core";
+
+async function main() {
+  // PostgreSQL connection configuration
+  const poolConfig = process.env.DATABASE_URL || "postgresql://user:password@localhost:5432/axiom";
+
+  console.log("=== PostgreSQL Workspace and Project Store Example ===\n");
+
+  try {
+    // Create store instances
+    const workspaceStore = new PostgreSQLWorkspaceStore({
+      poolConfig,
+      autoMigrate: true,
+    });
+
+    const projectStore = new PostgreSQLProjectStore({
+      poolConfig,
+      autoMigrate: true,
+    });
+
+    // Wait for stores to initialize
+    await workspaceStore.initialize();
+    await projectStore.initialize();
+
+    console.log("✓ Stores initialized successfully\n");
+
+    const tenantId = "tenant-001";
+
+    // ============ Workspace Operations ============
+    console.log("--- Workspace Operations ---");
+
+    // Create workspaces
+    const workspace1 = await workspaceStore.createWorkspace(tenantId, "ws-001", {
+      name: "Development Workspace",
+      description: "For development team",
+      storageType: "filesystem",
+    });
+    console.log("Created workspace:", workspace1.name);
+
+    const workspace2 = await workspaceStore.createWorkspace(tenantId, "ws-002", {
+      name: "Production Workspace",
+      description: "For production systems",
+      storageType: "sandbox",
+    });
+    console.log("Created workspace:", workspace2.name);
+
+    // Get all workspaces
+    const allWorkspaces = await workspaceStore.getAllWorkspaces(tenantId);
+    console.log(`\nTotal workspaces: ${allWorkspaces.length}`);
+    allWorkspaces.forEach((ws) => {
+      console.log(`  - ${ws.name} (${ws.storageType})`);
+    });
+
+    // Update workspace
+    const updated = await workspaceStore.updateWorkspace(tenantId, "ws-001", {
+      description: "Updated description for dev team",
+    });
+    console.log("\nUpdated workspace:", updated?.description);
+
+    // ============ Project Operations ============
+    console.log("\n--- Project Operations ---");
+
+    // Create projects in workspace1
+    const project1 = await projectStore.createProject(tenantId, "ws-001", "proj-001", {
+      name: "API Service",
+      description: "REST API development",
+    });
+    console.log("Created project:", project1.name, "in workspace:", workspace1.name);
+
+    const project2 = await projectStore.createProject(tenantId, "ws-001", "proj-002", {
+      name: "Web Frontend",
+      description: "React frontend application",
+    });
+    console.log("Created project:", project2.name, "in workspace:", workspace1.name);
+
+    // Create project in workspace2
+    const project3 = await projectStore.createProject(tenantId, "ws-002", "proj-003", {
+      name: "Monitoring System",
+      description: "System monitoring and alerting",
+    });
+    console.log("Created project:", project3.name, "in workspace:", workspace2.name);
+
+    // Get projects by workspace
+    const ws1Projects = await projectStore.getProjectsByWorkspace(tenantId, "ws-001");
+    console.log(`\nProjects in '${workspace1.name}':`);
+    ws1Projects.forEach((proj) => {
+      console.log(`  - ${proj.name}: ${proj.description}`);
+    });
+
+    // Get single project
+    const fetchedProject = await projectStore.getProjectById(tenantId, "proj-001");
+    console.log("\nFetched project by ID:", fetchedProject?.name);
+
+    // Update project
+    const updatedProject = await projectStore.updateProject(tenantId, "proj-001", {
+      description: "REST API development - Version 2.0",
+    });
+    console.log("Updated project description:", updatedProject?.description);
+
+    // ============ Register to StoreLatticeManager ============
+    console.log("\n--- Registering to StoreLatticeManager ---");
+
+    storeLatticeManager.registerLattice("production", "workspace", workspaceStore);
+    storeLatticeManager.registerLattice("production", "project", projectStore);
+
+    console.log("✓ Registered PostgreSQL stores as 'production' in StoreLatticeManager");
+
+    // Verify registration
+    const registeredWsStore = storeLatticeManager.getStoreLattice("production", "workspace");
+    const registeredProjStore = storeLatticeManager.getStoreLattice("production", "project");
+    console.log("✓ Can retrieve stores from manager");
+
+    // ============ Cleanup ============
+    console.log("\n--- Cleanup ---");
+
+    // Delete projects
+    await projectStore.deleteProject(tenantId, "proj-001");
+    await projectStore.deleteProject(tenantId, "proj-002");
+    await projectStore.deleteProject(tenantId, "proj-003");
+    console.log("✓ Deleted all projects");
+
+    // Delete workspaces
+    await workspaceStore.deleteWorkspace(tenantId, "ws-001");
+    await workspaceStore.deleteWorkspace(tenantId, "ws-002");
+    console.log("✓ Deleted all workspaces");
+
+    // Dispose stores
+    await workspaceStore.dispose();
+    await projectStore.dispose();
+    console.log("✓ Disposed store connections");
+
+    console.log("\n=== Example completed successfully! ===");
+
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+}
+
+// Run the example
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "dependencies": {
     "pg": "^8.16.3",
-    "@axiom-lattice/protocols": "2.1.13",
-    "@axiom-lattice/core": "2.1.23"
+    "@axiom-lattice/protocols": "2.1.14",
+    "@axiom-lattice/core": "2.1.24"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

package/src/__tests__/workspace-project-store.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Tests for PostgreSQLWorkspaceStore and PostgreSQLProjectStore
+ */
+
+import { PostgreSQLWorkspaceStore } from "../stores/PostgreSQLWorkspaceStore";
+import { PostgreSQLProjectStore } from "../stores/PostgreSQLProjectStore";
+import { StorageType } from "@axiom-lattice/protocols";
+
+// Skip tests if no database URL is provided
+const TEST_DATABASE_URL = process.env.TEST_DATABASE_URL;
+
+const describeIfDb = TEST_DATABASE_URL ? describe : describe.skip;
+
+describeIfDb("PostgreSQLWorkspaceStore", () => {
+  let store: PostgreSQLWorkspaceStore;
+  const tenantId = "test-tenant";
+
+  beforeAll(async () => {
+    store = new PostgreSQLWorkspaceStore({
+      poolConfig: TEST_DATABASE_URL!,
+      autoMigrate: true,
+    });
+    await store.initialize();
+  });
+
+  afterAll(async () => {
+    await store.dispose();
+  });
+
+  beforeEach(async () => {
+    // Clean up any existing test data
+    const workspaces = await store.getAllWorkspaces(tenantId);
+    for (const ws of workspaces) {
+      if (ws.id.startsWith("test-")) {
+        await store.deleteWorkspace(tenantId, ws.id);
+      }
+    }
+  });
+
+  test("should create a workspace", async () => {
+    const workspace = await store.createWorkspace(tenantId, "test-ws-001", {
+      name: "Test Workspace",
+      description: "Test description",
+      storageType: "filesystem" as StorageType,
+    });
+
+    expect(workspace.id).toBe("test-ws-001");
+    expect(workspace.name).toBe("Test Workspace");
+    expect(workspace.description).toBe("Test description");
+    expect(workspace.storageType).toBe("filesystem");
+    expect(workspace.tenantId).toBe(tenantId);
+  });
+
+  test("should get a workspace by ID", async () => {
+    await store.createWorkspace(tenantId, "test-ws-002", {
+      name: "Test Workspace 2",
+      storageType: "sandbox" as StorageType,
+    });
+
+    const fetched = await store.getWorkspaceById(tenantId, "test-ws-002");
+    expect(fetched).not.toBeNull();
+    expect(fetched?.name).toBe("Test Workspace 2");
+    expect(fetched?.storageType).toBe("sandbox");
+  });
+
+  test("should return null for non-existent workspace", async () => {
+    const fetched = await store.getWorkspaceById(tenantId, "non-existent");
+    expect(fetched).toBeNull();
+  });
+
+  test("should get all workspaces for a tenant", async () => {
+    await store.createWorkspace(tenantId, "test-ws-003", {
+      name: "Workspace 3",
+      storageType: "sandbox" as StorageType,
+    });
+    await store.createWorkspace(tenantId, "test-ws-004", {
+      name: "Workspace 4",
+      storageType: "filesystem" as StorageType,
+    });
+
+    const workspaces = await store.getAllWorkspaces(tenantId);
+    const testWorkspaces = workspaces.filter((ws) => ws.id.startsWith("test-"));
+    expect(testWorkspaces.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("should update a workspace", async () => {
+    await store.createWorkspace(tenantId, "test-ws-005", {
+      name: "Original Name",
+      storageType: "sandbox" as StorageType,
+    });
+
+    const updated = await store.updateWorkspace(tenantId, "test-ws-005", {
+      name: "Updated Name",
+      description: "Updated description",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated?.name).toBe("Updated Name");
+    expect(updated?.description).toBe("Updated description");
+  });
+
+  test("should return null when updating non-existent workspace", async () => {
+    const updated = await store.updateWorkspace(tenantId, "non-existent", {
+      name: "New Name",
+    });
+    expect(updated).toBeNull();
+  });
+
+  test("should delete a workspace", async () => {
+    await store.createWorkspace(tenantId, "test-ws-006", {
+      name: "To Delete",
+      storageType: "sandbox" as StorageType,
+    });
+
+    const deleted = await store.deleteWorkspace(tenantId, "test-ws-006");
+    expect(deleted).toBe(true);
+
+    const fetched = await store.getWorkspaceById(tenantId, "test-ws-006");
+    expect(fetched).toBeNull();
+  });
+
+  test("should return false when deleting non-existent workspace", async () => {
+    const deleted = await store.deleteWorkspace(tenantId, "non-existent");
+    expect(deleted).toBe(false);
+  });
+});
+
+describeIfDb("PostgreSQLProjectStore", () => {
+  let store: PostgreSQLProjectStore;
+  const tenantId = "test-tenant";
+  const workspaceId = "test-workspace";
+
+  beforeAll(async () => {
+    store = new PostgreSQLProjectStore({
+      poolConfig: TEST_DATABASE_URL!,
+      autoMigrate: true,
+    });
+    await store.initialize();
+  });
+
+  afterAll(async () => {
+    await store.dispose();
+  });
+
+  beforeEach(async () => {
+    // Clean up any existing test data
+    const projects = await store.getProjectsByWorkspace(tenantId, workspaceId);
+    for (const proj of projects) {
+      if (proj.id.startsWith("test-")) {
+        await store.deleteProject(tenantId, proj.id);
+      }
+    }
+  });
+
+  test("should create a project", async () => {
+    const project = await store.createProject(tenantId, workspaceId, "test-proj-001", {
+      name: "Test Project",
+      description: "Test project description",
+    });
+
+    expect(project.id).toBe("test-proj-001");
+    expect(project.name).toBe("Test Project");
+    expect(project.description).toBe("Test project description");
+    expect(project.workspaceId).toBe(workspaceId);
+    expect(project.tenantId).toBe(tenantId);
+  });
+
+  test("should get a project by ID", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-002", {
+      name: "Test Project 2",
+      description: "Description 2",
+    });
+
+    const fetched = await store.getProjectById(tenantId, "test-proj-002");
+    expect(fetched).not.toBeNull();
+    expect(fetched?.name).toBe("Test Project 2");
+  });
+
+  test("should return null for non-existent project", async () => {
+    const fetched = await store.getProjectById(tenantId, "non-existent");
+    expect(fetched).toBeNull();
+  });
+
+  test("should get projects by workspace", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-003", {
+      name: "Project 3",
+    });
+    await store.createProject(tenantId, workspaceId, "test-proj-004", {
+      name: "Project 4",
+    });
+
+    const projects = await store.getProjectsByWorkspace(tenantId, workspaceId);
+    const testProjects = projects.filter((p) => p.id.startsWith("test-"));
+    expect(testProjects.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("should update a project", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-005", {
+      name: "Original Name",
+    });
+
+    const updated = await store.updateProject(tenantId, "test-proj-005", {
+      name: "Updated Name",
+      description: "Updated description",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated?.name).toBe("Updated Name");
+    expect(updated?.description).toBe("Updated description");
+  });
+
+  test("should return null when updating non-existent project", async () => {
+    const updated = await store.updateProject(tenantId, "non-existent", {
+      name: "New Name",
+    });
+    expect(updated).toBeNull();
+  });
+
+  test("should delete a project", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-006", {
+      name: "To Delete",
+    });
+
+    const deleted = await store.deleteProject(tenantId, "test-proj-006");
+    expect(deleted).toBe(true);
+
+    const fetched = await store.getProjectById(tenantId, "test-proj-006");
+    expect(fetched).toBeNull();
+  });
+
+  test("should return false when deleting non-existent project", async () => {
+    const deleted = await store.deleteProject(tenantId, "non-existent");
+    expect(deleted).toBe(false);
+  });
+});

package/src/index.ts

@@ -8,17 +8,26 @@ export * from "./stores/PostgreSQLThreadStore";
 export * from "./stores/PostgreSQLAssistantStore";
 export * from "./stores/PostgreSQLScheduleStorage";
 export * from "./stores/PostgreSQLSkillStore";
+export * from "./stores/PostgreSQLDatabaseConfigStore";
+export * from "./stores/PostgreSQLWorkspaceStore";
+export * from "./stores/PostgreSQLProjectStore";
 export * from "./migrations/migration";
 export * from "./migrations/thread_migrations";
 export * from "./migrations/assistant_migrations";
 export * from "./migrations/schedule_migrations";
 export * from "./migrations/skill_migrations";
+export * from "./migrations/database_config_migrations";
+export * from "./migrations/workspace_migrations";
+export * from "./migrations/project_migrations";
 
 // Re-export for convenience
 export { PostgreSQLThreadStore } from "./stores/PostgreSQLThreadStore";
 export { PostgreSQLAssistantStore } from "./stores/PostgreSQLAssistantStore";
 export { PostgreSQLScheduleStorage } from "./stores/PostgreSQLScheduleStorage";
 export { PostgreSQLSkillStore } from "./stores/PostgreSQLSkillStore";
+export { PostgreSQLDatabaseConfigStore } from "./stores/PostgreSQLDatabaseConfigStore";
+export { PostgreSQLWorkspaceStore } from "./stores/PostgreSQLWorkspaceStore";
+export { PostgreSQLProjectStore } from "./stores/PostgreSQLProjectStore";
 
 // Re-export types from protocols
 export type {
@@ -35,4 +44,19 @@ export type {
   SkillStore,
   Skill,
   CreateSkillRequest,
+  DatabaseConfigStore,
+  DatabaseConfigEntry,
+  CreateDatabaseConfigRequest,
+  UpdateDatabaseConfigRequest,
+  DatabaseConfig,
+  DatabaseType,
+  WorkspaceStore,
+  Workspace,
+  CreateWorkspaceRequest,
+  UpdateWorkspaceRequest,
+  StorageType,
+  ProjectStore,
+  Project,
+  CreateProjectRequest,
+  UpdateProjectRequest,
 } from "@axiom-lattice/protocols";

package/src/migrations/database_config_migrations.ts

@@ -0,0 +1,47 @@
+/**
+ * Database configuration table migrations
+ */
+
+import { PoolClient } from 'pg';
+import { Migration } from './migration';
+
+/**
+ * Initial migration: Create database configs table
+ */
+export const createDatabaseConfigsTable: Migration = {
+  version: 4,
+  name: 'create_database_configs_table',
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_database_configs (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        key VARCHAR(255) NOT NULL,
+        name VARCHAR(255),
+        description TEXT,
+        config JSONB NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        
+        PRIMARY KEY (tenant_id, id),
+        CONSTRAINT uk_lattice_database_configs_tenant_key UNIQUE (tenant_id, key)
+      )
+    `);
+
+    // Create indexes for better query performance
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_database_configs_tenant_id 
+      ON lattice_database_configs(tenant_id)
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_database_configs_key 
+      ON lattice_database_configs(key)
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query('DROP INDEX IF EXISTS idx_lattice_database_configs_key');
+    await client.query('DROP INDEX IF EXISTS idx_lattice_database_configs_tenant_id');
+    await client.query('DROP TABLE IF EXISTS lattice_database_configs');
+  },
+};