@axiom-lattice/pg-stores 1.0.13 → 1.0.14

package/src/migrations/project_migrations.ts

@@ -0,0 +1,50 @@
+/**
+ * Project table migrations
+ */
+
+import { PoolClient } from "pg";
+import { Migration } from "./migration";
+
+/**
+ * Initial migration: Create projects table
+ */
+export const createProjectsTable: Migration = {
+  version: 6,
+  name: "create_projects_table",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_projects (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        workspace_id VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (id, tenant_id)
+      )
+    `);
+
+    // Create indexes for better query performance
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_projects_tenant_id 
+      ON lattice_projects(tenant_id)
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_projects_workspace_id 
+      ON lattice_projects(workspace_id)
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_projects_created_at 
+      ON lattice_projects(created_at DESC)
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_projects_created_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_projects_workspace_id");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_projects_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_projects");
+  },
+};

package/src/migrations/workspace_migrations.ts

@@ -0,0 +1,44 @@
+/**
+ * Workspace table migrations
+ */
+
+import { PoolClient } from "pg";
+import { Migration } from "./migration";
+
+/**
+ * Initial migration: Create workspaces table
+ */
+export const createWorkspacesTable: Migration = {
+  version: 5,
+  name: "create_workspaces_table",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_workspaces (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        storage_type VARCHAR(50) NOT NULL DEFAULT 'sandbox',
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (id, tenant_id)
+      )
+    `);
+
+    // Create indexes for better query performance
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_workspaces_tenant_id 
+      ON lattice_workspaces(tenant_id)
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_workspaces_created_at 
+      ON lattice_workspaces(created_at DESC)
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_workspaces_created_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_workspaces_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_workspaces");
+  },
+};

package/src/stores/PostgreSQLDatabaseConfigStore.ts

@@ -0,0 +1,434 @@
+/**
+ * PostgreSQL implementation of DatabaseConfigStore
+ */
+
+import { Pool, PoolClient, PoolConfig } from 'pg';
+import {
+  DatabaseConfigStore,
+  DatabaseConfigEntry,
+  CreateDatabaseConfigRequest,
+  UpdateDatabaseConfigRequest,
+  DatabaseConfig,
+} from '@axiom-lattice/protocols';
+import { MigrationManager } from '../migrations/migration';
+import { createDatabaseConfigsTable } from '../migrations/database_config_migrations';
+import { encrypt, decrypt } from '@axiom-lattice/core';
+
+/**
+ * PostgreSQL DatabaseConfigStore options
+ */
+export interface PostgreSQLDatabaseConfigStoreOptions {
+  /**
+   * PostgreSQL connection pool configuration
+   * Can be a connection string or PoolConfig object
+   */
+  poolConfig: string | PoolConfig;
+
+  /**
+   * Whether to run migrations automatically on initialization
+   * @default true
+   */
+  autoMigrate?: boolean;
+}
+
+/**
+ * PostgreSQL implementation of DatabaseConfigStore
+ * 
+ * Features:
+ * - Multi-tenant isolation via tenant_id
+ * - Automatic password encryption/decryption
+ * - Unique constraint on (tenant_id, key)
+ */
+export class PostgreSQLDatabaseConfigStore implements DatabaseConfigStore {
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized: boolean = false;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(options: PostgreSQLDatabaseConfigStoreOptions) {
+    // Create Pool from config
+    if (typeof options.poolConfig === 'string') {
+      this.pool = new Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new Pool(options.poolConfig);
+    }
+
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createDatabaseConfigsTable);
+
+    // Auto-migrate by default
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error('Failed to initialize PostgreSQLDatabaseConfigStore:', error);
+        throw error;
+      });
+    }
+  }
+
+  /**
+   * Initialize the store and run migrations
+   * Uses a promise-based lock to prevent concurrent initialization
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+
+    return this.initPromise;
+  }
+
+  /**
+   * Get all database configurations for a tenant
+   */
+  async getAllConfigs(tenantId: string): Promise<DatabaseConfigEntry[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      key: string;
+      name: string | null;
+      description: string | null;
+      config: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, key, name, description, config, created_at, updated_at
+      FROM lattice_database_configs
+      WHERE tenant_id = $1
+      ORDER BY created_at DESC
+    `,
+      [tenantId]
+    );
+
+    return result.rows.map((row) => this.mapRowToEntry(row));
+  }
+
+  /**
+   * Get all database configurations across all tenants
+   */
+  async getAllConfigsWithoutTenant(): Promise<DatabaseConfigEntry[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      key: string;
+      name: string | null;
+      description: string | null;
+      config: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, key, name, description, config, created_at, updated_at
+      FROM lattice_database_configs
+      ORDER BY created_at DESC
+    `
+    );
+
+    return result.rows.map((row) => this.mapRowToEntry(row));
+  }
+
+  /**
+   * Get database configuration by ID
+   */
+  async getConfigById(tenantId: string, id: string): Promise<DatabaseConfigEntry | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      key: string;
+      name: string | null;
+      description: string | null;
+      config: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, key, name, description, config, created_at, updated_at
+      FROM lattice_database_configs
+      WHERE tenant_id = $1 AND id = $2
+    `,
+      [tenantId, id]
+    );
+
+    if (result.rows.length === 0) {
+      return null;
+    }
+
+    return this.mapRowToEntry(result.rows[0]);
+  }
+
+  /**
+   * Get database configuration by business key
+   */
+  async getConfigByKey(tenantId: string, key: string): Promise<DatabaseConfigEntry | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      key: string;
+      name: string | null;
+      description: string | null;
+      config: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, key, name, description, config, created_at, updated_at
+      FROM lattice_database_configs
+      WHERE tenant_id = $1 AND key = $2
+    `,
+      [tenantId, key]
+    );
+
+    if (result.rows.length === 0) {
+      return null;
+    }
+
+    return this.mapRowToEntry(result.rows[0]);
+  }
+
+  /**
+   * Create a new database configuration
+   */
+  async createConfig(
+    tenantId: string,
+    id: string,
+    data: CreateDatabaseConfigRequest
+  ): Promise<DatabaseConfigEntry> {
+    await this.ensureInitialized();
+
+    const now = new Date();
+    const nowString = now.toISOString();
+    const configWithEncryptedPassword = this.encryptPasswordInConfig(data.config);
+
+    await this.pool.query(
+      `
+      INSERT INTO lattice_database_configs (id, tenant_id, key, name, description, config, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7::timestamp, $8::timestamp)
+      ON CONFLICT (tenant_id, id) DO UPDATE SET
+        key = EXCLUDED.key,
+        name = EXCLUDED.name,
+        description = EXCLUDED.description,
+        config = EXCLUDED.config,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [
+        id,
+        tenantId,
+        data.key,
+        data.name || null,
+        data.description || null,
+        JSON.stringify(configWithEncryptedPassword),
+        nowString,
+        nowString,
+      ]
+    );
+
+    return {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now,
+    };
+  }
+
+  /**
+   * Update an existing database configuration
+   */
+  async updateConfig(
+    tenantId: string,
+    id: string,
+    updates: Partial<UpdateDatabaseConfigRequest>
+  ): Promise<DatabaseConfigEntry | null> {
+    await this.ensureInitialized();
+
+    const existing = await this.getConfigById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+
+    // Build update fields and values as key-value pairs for clarity
+    const updateData: Record<string, any> = {};
+
+    if (updates.key !== undefined) {
+      updateData.key = updates.key;
+    }
+
+    if (updates.name !== undefined) {
+      updateData.name = updates.name || null;
+    }
+
+    if (updates.description !== undefined) {
+      updateData.description = updates.description || null;
+    }
+
+    if (updates.config !== undefined) {
+      const configWithEncryptedPassword = this.encryptPasswordInConfig(updates.config);
+      updateData.config = JSON.stringify(configWithEncryptedPassword);
+    }
+
+    if (Object.keys(updateData).length === 0) {
+      return existing;
+    }
+
+    // Always update the updated_at timestamp
+    updateData.updated_at = new Date().toISOString();
+
+    // Build SQL with tenantId and id at fixed positions at the end
+    const fields = Object.keys(updateData);
+    const values = Object.values(updateData);
+    
+    // Add WHERE clause values at the end
+    values.push(tenantId);
+    values.push(id);
+
+    // Build SET clause with numbered parameters
+    const setClauses = fields.map((field, index) => {
+      if (field === 'updated_at') {
+        return `${field} = $${index + 1}::timestamp`;
+      }
+      return `${field} = $${index + 1}`;
+    });
+
+    // WHERE clause parameters are at the end
+    const whereTenantIndex = fields.length + 1;
+    const whereIdIndex = fields.length + 2;
+
+    const sql = `
+      UPDATE lattice_database_configs
+      SET ${setClauses.join(', ')}
+      WHERE tenant_id = $${whereTenantIndex} AND id = $${whereIdIndex}
+    `;
+
+    await this.pool.query(sql, values);
+
+    return await this.getConfigById(tenantId, id);
+  }
+
+  /**
+   * Delete a database configuration by ID
+   */
+  async deleteConfig(tenantId: string, id: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_database_configs
+      WHERE tenant_id = $1 AND id = $2
+    `,
+      [tenantId, id]
+    );
+
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+
+  /**
+   * Check if configuration exists
+   */
+  async hasConfig(tenantId: string, id: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query(
+      `
+      SELECT 1 FROM lattice_database_configs
+      WHERE tenant_id = $1 AND id = $2
+      LIMIT 1
+    `,
+      [tenantId, id]
+    );
+
+    return result.rows.length > 0;
+  }
+
+  /**
+   * Dispose resources and close the connection pool
+   */
+  async dispose(): Promise<void> {
+    await this.pool.end();
+  }
+
+  /**
+   * Ensure store is initialized
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  /**
+   * Map database row to DatabaseConfigEntry object
+   * Automatically decrypts password if present
+   */
+  private mapRowToEntry(row: {
+    id: string;
+    tenant_id: string;
+    key: string;
+    name: string | null;
+    description: string | null;
+    config: any;
+    created_at: Date;
+    updated_at: Date;
+  }): DatabaseConfigEntry {
+    const config: DatabaseConfig = typeof row.config === 'string'
+      ? JSON.parse(row.config)
+      : row.config;
+
+    // Decrypt password if present
+    if (config.password) {
+      try {
+        config.password = decrypt(config.password);
+      } catch (error) {
+        console.error('Failed to decrypt database password:', error);
+        throw new Error('Failed to decrypt database configuration');
+      }
+    }
+
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      key: row.key,
+      config,
+      name: row.name || undefined,
+      description: row.description || undefined,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Encrypt password in config before storing
+   */
+  private encryptPasswordInConfig(config: DatabaseConfig): DatabaseConfig {
+    const configCopy = { ...config };
+    
+    if (configCopy.password) {
+      configCopy.password = encrypt(configCopy.password);
+    }
+    
+    return configCopy;
+  }
+}