@axiom-lattice/pg-stores 1.0.4 → 1.0.5

package/src/stores/PostgreSQLSkillStore.ts

@@ -0,0 +1,455 @@
+/**
+ * PostgreSQL implementation of SkillStore
+ */
+
+import { Pool, PoolConfig } from "pg";
+import {
+  SkillStore,
+  Skill,
+  CreateSkillRequest,
+} from "@axiom-lattice/protocols";
+import { MigrationManager } from "../migrations/migration";
+import { createSkillsTable } from "../migrations/skill_migrations";
+
+/**
+ * PostgreSQL SkillStore options
+ */
+export interface PostgreSQLSkillStoreOptions {
+  /**
+   * 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 SkillStore
+ */
+export class PostgreSQLSkillStore implements SkillStore {
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized: boolean = false;
+  private ownsPool: boolean = true;
+
+  constructor(options: PostgreSQLSkillStoreOptions) {
+    // 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(createSkillsTable);
+
+    // Auto-migrate by default
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLSkillStore:", 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 Skill object
+   */
+  private mapRowToSkill(row: {
+    id: string;
+    name: string;
+    description: string;
+    license: string | null;
+    compatibility: string | null;
+    metadata: any;
+    content: string | null;
+    sub_skills: any;
+    created_at: Date;
+    updated_at: Date;
+  }): Skill {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      license: row.license || undefined,
+      compatibility: row.compatibility || undefined,
+      metadata: row.metadata || {},
+      content: row.content || undefined,
+      subSkills: Array.isArray(row.sub_skills) && row.sub_skills.length > 0 
+        ? row.sub_skills 
+        : undefined,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get all skills
+   */
+  async getAllSkills(): Promise<Skill[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      name: string;
+      description: string;
+      license: string | null;
+      compatibility: string | null;
+      metadata: any;
+      content: string | null;
+      sub_skills: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      ORDER BY created_at DESC
+    `
+    );
+
+    return result.rows.map(this.mapRowToSkill);
+  }
+
+  /**
+   * Get skill by ID
+   */
+  async getSkillById(id: string): Promise<Skill | null> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      name: string;
+      description: string;
+      license: string | null;
+      compatibility: string | null;
+      metadata: any;
+      content: string | null;
+      sub_skills: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE id = $1
+    `,
+      [id]
+    );
+
+    if (result.rows.length === 0) {
+      return null;
+    }
+
+    return this.mapRowToSkill(result.rows[0]);
+  }
+
+  /**
+   * Create a new skill
+   */
+  async createSkill(id: string, data: CreateSkillRequest): Promise<Skill> {
+    await this.ensureInitialized();
+
+    const now = new Date();
+    const metadata = data.metadata || {};
+
+    await this.pool.query(
+      `
+      INSERT INTO lattice_skills (id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+      ON CONFLICT (id) DO UPDATE SET
+        name = EXCLUDED.name,
+        description = EXCLUDED.description,
+        license = EXCLUDED.license,
+        compatibility = EXCLUDED.compatibility,
+        metadata = EXCLUDED.metadata,
+        content = EXCLUDED.content,
+        sub_skills = EXCLUDED.sub_skills,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [
+        id,
+        data.name,
+        data.description,
+        data.license || null,
+        data.compatibility || null,
+        JSON.stringify(metadata),
+        data.content || null,
+        JSON.stringify(data.subSkills || []),
+        now,
+        now,
+      ]
+    );
+
+    return this.getSkillById(id) as Promise<Skill>;
+  }
+
+  /**
+   * Update an existing skill
+   */
+  async updateSkill(
+    id: string,
+    updates: Partial<CreateSkillRequest>
+  ): Promise<Skill | null> {
+    await this.ensureInitialized();
+
+    const updateFields: string[] = [];
+    const values: any[] = [];
+    let paramIndex = 1;
+
+    if (updates.name !== undefined) {
+      updateFields.push(`name = $${paramIndex++}`);
+      values.push(updates.name);
+    }
+
+    if (updates.description !== undefined) {
+      updateFields.push(`description = $${paramIndex++}`);
+      values.push(updates.description);
+    }
+
+    if (updates.license !== undefined) {
+      updateFields.push(`license = $${paramIndex++}`);
+      values.push(updates.license || null);
+    }
+
+    if (updates.compatibility !== undefined) {
+      updateFields.push(`compatibility = $${paramIndex++}`);
+      values.push(updates.compatibility || null);
+    }
+
+    if (updates.metadata !== undefined) {
+      updateFields.push(`metadata = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.metadata || {}));
+    }
+
+    if (updates.content !== undefined) {
+      updateFields.push(`content = $${paramIndex++}`);
+      values.push(updates.content || null);
+    }
+
+    if (updates.subSkills !== undefined) {
+      updateFields.push(`sub_skills = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.subSkills || []));
+    }
+
+    if (updateFields.length === 0) {
+      return this.getSkillById(id);
+    }
+
+    updateFields.push(`updated_at = $${paramIndex++}`);
+    values.push(new Date());
+    values.push(id);
+
+    await this.pool.query(
+      `
+      UPDATE lattice_skills
+      SET ${updateFields.join(", ")}
+      WHERE id = $${paramIndex}
+    `,
+      values
+    );
+
+    return this.getSkillById(id);
+  }
+
+  /**
+   * Delete a skill by ID
+   */
+  async deleteSkill(id: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_skills
+      WHERE id = $1
+    `,
+      [id]
+    );
+
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+
+  /**
+   * Check if skill exists
+   */
+  async hasSkill(id: string): Promise<boolean> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{ count: string }>(
+      `
+      SELECT COUNT(*) as count
+      FROM lattice_skills
+      WHERE id = $1
+    `,
+      [id]
+    );
+
+    return parseInt(result.rows[0].count, 10) > 0;
+  }
+
+  /**
+   * Search skills by metadata
+   */
+  async searchByMetadata(
+    metadataKey: string,
+    metadataValue: string
+  ): Promise<Skill[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      name: string;
+      description: string;
+      license: string | null;
+      compatibility: string | null;
+      metadata: any;
+      content: string | null;
+      sub_skills: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE metadata->>$1 = $2
+      ORDER BY created_at DESC
+    `,
+      [metadataKey, metadataValue]
+    );
+
+    return result.rows.map(this.mapRowToSkill);
+  }
+
+  /**
+   * Filter skills by compatibility
+   */
+  async filterByCompatibility(compatibility: string): Promise<Skill[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      name: string;
+      description: string;
+      license: string | null;
+      compatibility: string | null;
+      metadata: any;
+      content: string | null;
+      sub_skills: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE compatibility = $1
+      ORDER BY created_at DESC
+    `,
+      [compatibility]
+    );
+
+    return result.rows.map(this.mapRowToSkill);
+  }
+
+  /**
+   * Filter skills by license
+   */
+  async filterByLicense(license: string): Promise<Skill[]> {
+    await this.ensureInitialized();
+
+    const result = await this.pool.query<{
+      id: string;
+      name: string;
+      description: string;
+      license: string | null;
+      compatibility: string | null;
+      metadata: any;
+      content: string | null;
+      sub_skills: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE license = $1
+      ORDER BY created_at DESC
+    `,
+      [license]
+    );
+
+    return result.rows.map(this.mapRowToSkill);
+  }
+
+  /**
+   * Get sub-skills of a parent skill
+   */
+  async getSubSkills(parentSkillName: string): Promise<Skill[]> {
+    await this.ensureInitialized();
+
+    const parentSkill = await this.getSkillById(parentSkillName);
+    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
+      return [];
+    }
+
+    // Query all sub-skills in one query
+    const placeholders = parentSkill.subSkills.map((_, index) => `$${index + 1}`).join(", ");
+    const result = await this.pool.query<{
+      id: string;
+      name: string;
+      description: string;
+      license: string | null;
+      compatibility: string | null;
+      metadata: any;
+      content: string | null;
+      sub_skills: any;
+      created_at: Date;
+      updated_at: Date;
+    }>(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE name IN (${placeholders})
+      ORDER BY created_at DESC
+    `,
+      parentSkill.subSkills
+    );
+
+    return result.rows.map(this.mapRowToSkill);
+  }
+}