@axiom-lattice/pg-stores 1.0.4 → 1.0.6

package/dist/index.js

@@ -23,9 +23,11 @@ __export(index_exports, {
   MigrationManager: () => MigrationManager,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
   PostgreSQLScheduleStorage: () => PostgreSQLScheduleStorage,
+  PostgreSQLSkillStore: () => PostgreSQLSkillStore,
   PostgreSQLThreadStore: () => PostgreSQLThreadStore,
   createAssistantsTable: () => createAssistantsTable,
   createScheduledTasksTable: () => createScheduledTasksTable,
+  createSkillsTable: () => createSkillsTable,
   createThreadsTable: () => createThreadsTable
 });
 module.exports = __toCommonJS(index_exports);
@@ -76,36 +78,45 @@ var MigrationManager = class {
   }
   /**
    * Apply pending migrations
+   * Uses PostgreSQL advisory locks to prevent concurrent migrations
    */
   async migrate() {
     const client = await this.pool.connect();
     try {
-      await client.query("BEGIN");
-      await this.ensureMigrationsTable(client);
-      const appliedMigrations = await this.getAppliedMigrations(client);
-      const appliedVersions = new Set(appliedMigrations.map((m) => m.version));
-      const pendingMigrations = this.migrations.filter(
-        (m) => !appliedVersions.has(m.version)
-      );
-      if (pendingMigrations.length === 0) {
-        console.log("No pending migrations");
-        await client.query("COMMIT");
-        return;
-      }
-      for (const migration of pendingMigrations) {
-        console.log(
-          `Applying migration ${migration.version}: ${migration.name}`
-        );
-        await migration.up(client);
-        await client.query(
-          "INSERT INTO lattice_schema_migrations (version, name) VALUES ($1, $2)",
-          [migration.version, migration.name]
+      const lockId = 123456789;
+      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+      try {
+        await client.query("BEGIN");
+        await this.ensureMigrationsTable(client);
+        const appliedMigrations = await this.getAppliedMigrations(client);
+        const appliedVersions = new Set(appliedMigrations.map((m) => m.version));
+        const pendingMigrations = this.migrations.filter(
+          (m) => !appliedVersions.has(m.version)
         );
+        if (pendingMigrations.length === 0) {
+          console.log("No pending migrations");
+          await client.query("COMMIT");
+          return;
+        }
+        for (const migration of pendingMigrations) {
+          console.log(
+            `Applying migration ${migration.version}: ${migration.name}`
+          );
+          await migration.up(client);
+          await client.query(
+            "INSERT INTO lattice_schema_migrations (version, name) VALUES ($1, $2) ON CONFLICT (version) DO NOTHING",
+            [migration.version, migration.name]
+          );
+        }
+        await client.query("COMMIT");
+        console.log(`Applied ${pendingMigrations.length} migration(s)`);
+      } catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+      } finally {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
       }
-      await client.query("COMMIT");
-      console.log(`Applied ${pendingMigrations.length} migration(s)`);
     } catch (error) {
-      await client.query("ROLLBACK");
       throw error;
     } finally {
       client.release();
@@ -200,9 +211,11 @@ var createThreadsTable = {
 
 // src/stores/PostgreSQLThreadStore.ts
 var PostgreSQLThreadStore = class {
+  // Promise-based lock to prevent concurrent initialization
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
+    this.initPromise = null;
     if (typeof options.poolConfig === "string") {
       this.pool = new import_pg.Pool({ connectionString: options.poolConfig });
     } else {
@@ -228,13 +241,24 @@ var PostgreSQLThreadStore = class {
   }
   /**
    * Initialize the store and run migrations
+   * Uses a promise-based lock to prevent concurrent initialization
    */
   async initialize() {
     if (this.initialized) {
       return;
     }
-    await this.migrationManager.migrate();
-    this.initialized = true;
+    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 threads for a specific assistant
@@ -1146,14 +1170,352 @@ var PostgreSQLScheduleStorage = class {
     };
   }
 };
+
+// src/stores/PostgreSQLSkillStore.ts
+var import_pg4 = require("pg");
+
+// src/migrations/skill_migrations.ts
+var createSkillsTable = {
+  version: 1,
+  name: "create_skills_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_skills (
+        id VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        description TEXT NOT NULL,
+        license VARCHAR(255),
+        compatibility VARCHAR(255),
+        metadata JSONB DEFAULT '{}',
+        content TEXT,
+        sub_skills JSONB DEFAULT '[]',
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_name 
+      ON lattice_skills(name)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_license 
+      ON lattice_skills(license)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_compatibility 
+      ON lattice_skills(compatibility)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_created_at 
+      ON lattice_skills(created_at DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_metadata 
+      ON lattice_skills USING GIN (metadata)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_metadata");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_created_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_compatibility");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_license");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_name");
+    await client.query("DROP TABLE IF EXISTS lattice_skills");
+  }
+};
+
+// src/stores/PostgreSQLSkillStore.ts
+var PostgreSQLSkillStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new import_pg4.Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new import_pg4.Pool(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createSkillsTable);
+    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() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  /**
+   * Initialize the store and run migrations
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.migrationManager.migrate();
+    this.initialized = true;
+  }
+  /**
+   * Ensure store is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Map database row to Skill object
+   */
+  mapRowToSkill(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      license: row.license || void 0,
+      compatibility: row.compatibility || void 0,
+      metadata: row.metadata || {},
+      content: row.content || void 0,
+      subSkills: Array.isArray(row.sub_skills) && row.sub_skills.length > 0 ? row.sub_skills : void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Get all skills
+   */
+  async getAllSkills() {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ 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);
+  }
+  /**
+   * Update an existing skill
+   */
+  async updateSkill(id, updates) {
+    await this.ensureInitialized();
+    const updateFields = [];
+    const values = [];
+    let paramIndex = 1;
+    if (updates.name !== void 0) {
+      updateFields.push(`name = $${paramIndex++}`);
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      updateFields.push(`description = $${paramIndex++}`);
+      values.push(updates.description);
+    }
+    if (updates.license !== void 0) {
+      updateFields.push(`license = $${paramIndex++}`);
+      values.push(updates.license || null);
+    }
+    if (updates.compatibility !== void 0) {
+      updateFields.push(`compatibility = $${paramIndex++}`);
+      values.push(updates.compatibility || null);
+    }
+    if (updates.metadata !== void 0) {
+      updateFields.push(`metadata = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.metadata || {}));
+    }
+    if (updates.content !== void 0) {
+      updateFields.push(`content = $${paramIndex++}`);
+      values.push(updates.content || null);
+    }
+    if (updates.subSkills !== void 0) {
+      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(/* @__PURE__ */ 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) {
+    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) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, metadataValue) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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) {
+    await this.ensureInitialized();
+    const parentSkill = await this.getSkillById(parentSkillName);
+    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
+      return [];
+    }
+    const placeholders = parentSkill.subSkills.map((_, index) => `$${index + 1}`).join(", ");
+    const result = await this.pool.query(
+      `
+      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);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MigrationManager,
   PostgreSQLAssistantStore,
   PostgreSQLScheduleStorage,
+  PostgreSQLSkillStore,
   PostgreSQLThreadStore,
   createAssistantsTable,
   createScheduledTasksTable,
+  createSkillsTable,
   createThreadsTable
 });
 //# sourceMappingURL=index.js.map