@axiom-lattice/pg-stores 1.0.13 → 1.0.14

package/src/stores/PostgreSQLProjectStore.ts

@@ -0,0 +1,282 @@
+/**
+ * PostgreSQL implementation of ProjectStore
+ */
+
+import { Pool, PoolConfig } from "pg";
+import {
+  ProjectStore,
+  Project,
+  CreateProjectRequest,
+  UpdateProjectRequest,
+} from "@axiom-lattice/protocols";
+import { MigrationManager } from "../migrations/migration";
+import { createProjectsTable } from "../migrations/project_migrations";
+
+/**
+ * PostgreSQL ProjectStore options
+ */
+export interface PostgreSQLProjectStoreOptions {
+  /**
+   * 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 ProjectStore
+ */
+export class PostgreSQLProjectStore implements ProjectStore {
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized: boolean = false;
+  private ownsPool: boolean = true;
+
+  constructor(options: PostgreSQLProjectStoreOptions) {
+    // 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(createProjectsTable);
+
+    // Auto-migrate by default
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLProjectStore:", error);
+        throw error;
+      });
+    }
+  }
+
+  /**
+   * Dispose resources and close the connection pool
+   * Should be called when the store is no longer needed
+   */
+  async dispose(): Promise<void> {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+
+  /**
+   * Initialize the store and run migrations
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    await this.migrationManager.migrate();
+    this.initialized = true;
+  }
+
+  /**
+   * Ensure store is initialized
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  /**
+   * Map database row to Project object
+   */
+  private mapRowToProject(row: {
+    id: string;
+    tenant_id: string;
+    workspace_id: string;
+    name: string;
+    description: string | null;
+    created_at: Date;
+    updated_at: Date;
+  }): Project {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      workspaceId: row.workspace_id,
+      name: row.name,
+      description: row.description || undefined,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get all projects for a specific workspace
+   */
+  async getProjectsByWorkspace(tenantId: string, workspaceId: string): Promise<Project[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      workspace_id: string;
+      name: string;
+      description: string | null;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, workspace_id, name, description, created_at, updated_at
+      FROM lattice_projects
+      WHERE tenant_id = $1 AND workspace_id = $2
+      ORDER BY created_at DESC
+    `,
+      [tenantId, workspaceId]
+    );
+
+    return result.rows.map(this.mapRowToProject);
+  }
+
+  /**
+   * Get a project by ID for a specific tenant
+   */
+  async getProjectById(tenantId: string, id: string): Promise<Project | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      workspace_id: string;
+      name: string;
+      description: string | null;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, workspace_id, name, description, created_at, updated_at
+      FROM lattice_projects
+      WHERE id = $1 AND tenant_id = $2
+    `,
+      [id, tenantId]
+    );
+
+    if (result.rows.length === 0) {
+      return null;
+    }
+
+    return this.mapRowToProject(result.rows[0]);
+  }
+
+  /**
+   * Create a new project
+   */
+  async createProject(
+    tenantId: string,
+    workspaceId: string,
+    id: string,
+    data: CreateProjectRequest
+  ): Promise<Project> {
+    await this.ensureInitialized();
+
+    const now = new Date();
+
+    await this.pool.query(
+      `
+      INSERT INTO lattice_projects (id, tenant_id, workspace_id, name, description, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7)
+      ON CONFLICT (id, tenant_id) DO UPDATE SET
+        workspace_id = EXCLUDED.workspace_id,
+        name = EXCLUDED.name,
+        description = EXCLUDED.description,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [id, tenantId, workspaceId, data.name, data.description || null, now, now]
+    );
+
+    return {
+      id,
+      tenantId,
+      workspaceId,
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now,
+    };
+  }
+
+  /**
+   * Update an existing project
+   */
+  async updateProject(
+    tenantId: string,
+    id: string,
+    updates: UpdateProjectRequest
+  ): Promise<Project | null> {
+    await this.ensureInitialized();
+
+    // Get existing project
+    const existing = await this.getProjectById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+
+    // Build update query dynamically based on provided fields
+    const updateFields: string[] = [];
+    const updateValues: any[] = [];
+    let paramIndex = 1;
+
+    if (updates.name !== undefined) {
+      updateFields.push(`name = $${paramIndex++}`);
+      updateValues.push(updates.name);
+    }
+
+    if (updates.description !== undefined) {
+      updateFields.push(`description = $${paramIndex++}`);
+      updateValues.push(updates.description || null);
+    }
+
+    if (updateFields.length === 0) {
+      // No fields to update
+      return existing;
+    }
+
+    // Always update updated_at
+    updateFields.push(`updated_at = $${paramIndex++}`);
+    updateValues.push(new Date());
+
+    // Add id and tenant_id for WHERE clause
+    updateValues.push(id);
+    updateValues.push(tenantId);
+
+    await this.pool.query(
+      `
+      UPDATE lattice_projects
+      SET ${updateFields.join(", ")}
+      WHERE id = $${paramIndex} AND tenant_id = $${paramIndex + 1}
+    `,
+      updateValues
+    );
+
+    // Return updated project
+    return await this.getProjectById(tenantId, id);
+  }
+
+  /**
+   * Delete a project by ID
+   */
+  async deleteProject(tenantId: string, id: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_projects
+      WHERE id = $1 AND tenant_id = $2
+    `,
+      [id, tenantId]
+    );
+
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+}

package/src/stores/PostgreSQLWorkspaceStore.ts

@@ -0,0 +1,286 @@
+/**
+ * PostgreSQL implementation of WorkspaceStore
+ */
+
+import { Pool, PoolConfig } from "pg";
+import {
+  WorkspaceStore,
+  Workspace,
+  CreateWorkspaceRequest,
+  UpdateWorkspaceRequest,
+} from "@axiom-lattice/protocols";
+import { MigrationManager } from "../migrations/migration";
+import { createWorkspacesTable } from "../migrations/workspace_migrations";
+
+/**
+ * PostgreSQL WorkspaceStore options
+ */
+export interface PostgreSQLWorkspaceStoreOptions {
+  /**
+   * 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 WorkspaceStore
+ */
+export class PostgreSQLWorkspaceStore implements WorkspaceStore {
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized: boolean = false;
+  private ownsPool: boolean = true;
+
+  constructor(options: PostgreSQLWorkspaceStoreOptions) {
+    // 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(createWorkspacesTable);
+
+    // Auto-migrate by default
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLWorkspaceStore:", error);
+        throw error;
+      });
+    }
+  }
+
+  /**
+   * Dispose resources and close the connection pool
+   * Should be called when the store is no longer needed
+   */
+  async dispose(): Promise<void> {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+
+  /**
+   * Initialize the store and run migrations
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    await this.migrationManager.migrate();
+    this.initialized = true;
+  }
+
+  /**
+   * Ensure store is initialized
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  /**
+   * Map database row to Workspace object
+   */
+  private mapRowToWorkspace(row: {
+    id: string;
+    tenant_id: string;
+    name: string;
+    description: string | null;
+    storage_type: string;
+    created_at: Date;
+    updated_at: Date;
+  }): Workspace {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      name: row.name,
+      description: row.description || undefined,
+      storageType: row.storage_type as Workspace["storageType"],
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get all workspaces for a tenant
+   */
+  async getAllWorkspaces(tenantId: string): Promise<Workspace[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      name: string;
+      description: string | null;
+      storage_type: string;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, name, description, storage_type, created_at, updated_at
+      FROM lattice_workspaces
+      WHERE tenant_id = $1
+      ORDER BY created_at DESC
+    `,
+      [tenantId]
+    );
+
+    return result.rows.map(this.mapRowToWorkspace);
+  }
+
+  /**
+   * Get a workspace by ID for a specific tenant
+   */
+  async getWorkspaceById(tenantId: string, id: string): Promise<Workspace | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      tenant_id: string;
+      name: string;
+      description: string | null;
+      storage_type: string;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, tenant_id, name, description, storage_type, created_at, updated_at
+      FROM lattice_workspaces
+      WHERE id = $1 AND tenant_id = $2
+    `,
+      [id, tenantId]
+    );
+
+    if (result.rows.length === 0) {
+      return null;
+    }
+
+    return this.mapRowToWorkspace(result.rows[0]);
+  }
+
+  /**
+   * Create a new workspace
+   */
+  async createWorkspace(
+    tenantId: string,
+    id: string,
+    data: CreateWorkspaceRequest
+  ): Promise<Workspace> {
+    await this.ensureInitialized();
+
+    const now = new Date();
+
+    await this.pool.query(
+      `
+      INSERT INTO lattice_workspaces (id, tenant_id, name, description, storage_type, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7)
+      ON CONFLICT (id, tenant_id) DO UPDATE SET
+        name = EXCLUDED.name,
+        description = EXCLUDED.description,
+        storage_type = EXCLUDED.storage_type,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [id, tenantId, data.name, data.description || null, data.storageType, now, now]
+    );
+
+    return {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      storageType: data.storageType,
+      createdAt: now,
+      updatedAt: now,
+    };
+  }
+
+  /**
+   * Update an existing workspace
+   */
+  async updateWorkspace(
+    tenantId: string,
+    id: string,
+    updates: UpdateWorkspaceRequest
+  ): Promise<Workspace | null> {
+    await this.ensureInitialized();
+
+    // Get existing workspace
+    const existing = await this.getWorkspaceById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+
+    // Build update query dynamically based on provided fields
+    const updateFields: string[] = [];
+    const updateValues: any[] = [];
+    let paramIndex = 1;
+
+    if (updates.name !== undefined) {
+      updateFields.push(`name = $${paramIndex++}`);
+      updateValues.push(updates.name);
+    }
+
+    if (updates.description !== undefined) {
+      updateFields.push(`description = $${paramIndex++}`);
+      updateValues.push(updates.description || null);
+    }
+
+    if (updates.storageType !== undefined) {
+      updateFields.push(`storage_type = $${paramIndex++}`);
+      updateValues.push(updates.storageType);
+    }
+
+    if (updateFields.length === 0) {
+      // No fields to update
+      return existing;
+    }
+
+    // Always update updated_at
+    updateFields.push(`updated_at = $${paramIndex++}`);
+    updateValues.push(new Date());
+
+    // Add id and tenant_id for WHERE clause
+    updateValues.push(id);
+    updateValues.push(tenantId);
+
+    await this.pool.query(
+      `
+      UPDATE lattice_workspaces
+      SET ${updateFields.join(", ")}
+      WHERE id = $${paramIndex} AND tenant_id = $${paramIndex + 1}
+    `,
+      updateValues
+    );
+
+    // Return updated workspace
+    return await this.getWorkspaceById(tenantId, id);
+  }
+
+  /**
+   * Delete a workspace by ID
+   */
+  async deleteWorkspace(tenantId: string, id: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_workspaces
+      WHERE id = $1 AND tenant_id = $2
+    `,
+      [id, tenantId]
+    );
+
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+}