@axiom-lattice/pg-stores 1.0.13 → 1.0.14

package/dist/index.js

@@ -22,13 +22,19 @@ var index_exports = {};
 __export(index_exports, {
   MigrationManager: () => MigrationManager,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
+  PostgreSQLDatabaseConfigStore: () => PostgreSQLDatabaseConfigStore,
+  PostgreSQLProjectStore: () => PostgreSQLProjectStore,
   PostgreSQLScheduleStorage: () => PostgreSQLScheduleStorage,
   PostgreSQLSkillStore: () => PostgreSQLSkillStore,
   PostgreSQLThreadStore: () => PostgreSQLThreadStore,
+  PostgreSQLWorkspaceStore: () => PostgreSQLWorkspaceStore,
   createAssistantsTable: () => createAssistantsTable,
+  createDatabaseConfigsTable: () => createDatabaseConfigsTable,
+  createProjectsTable: () => createProjectsTable,
   createScheduledTasksTable: () => createScheduledTasksTable,
   createSkillsTable: () => createSkillsTable,
-  createThreadsTable: () => createThreadsTable
+  createThreadsTable: () => createThreadsTable,
+  createWorkspacesTable: () => createWorkspacesTable
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1506,16 +1512,767 @@ var PostgreSQLSkillStore = class {
     return result.rows.map(this.mapRowToSkill);
   }
 };
+
+// src/stores/PostgreSQLDatabaseConfigStore.ts
+var import_pg5 = require("pg");
+
+// src/migrations/database_config_migrations.ts
+var createDatabaseConfigsTable = {
+  version: 4,
+  name: "create_database_configs_table",
+  up: async (client) => {
+    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)
+      )
+    `);
+    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) => {
+    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");
+  }
+};
+
+// src/stores/PostgreSQLDatabaseConfigStore.ts
+var import_core = require("@axiom-lattice/core");
+var PostgreSQLDatabaseConfigStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.initPromise = null;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new import_pg5.Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new import_pg5.Pool(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createDatabaseConfigsTable);
+    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() {
+    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) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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() {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, key) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, id, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ 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, id, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getConfigById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+    const updateData = {};
+    if (updates.key !== void 0) {
+      updateData.key = updates.key;
+    }
+    if (updates.name !== void 0) {
+      updateData.name = updates.name || null;
+    }
+    if (updates.description !== void 0) {
+      updateData.description = updates.description || null;
+    }
+    if (updates.config !== void 0) {
+      const configWithEncryptedPassword = this.encryptPasswordInConfig(updates.config);
+      updateData.config = JSON.stringify(configWithEncryptedPassword);
+    }
+    if (Object.keys(updateData).length === 0) {
+      return existing;
+    }
+    updateData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    const fields = Object.keys(updateData);
+    const values = Object.values(updateData);
+    values.push(tenantId);
+    values.push(id);
+    const setClauses = fields.map((field, index) => {
+      if (field === "updated_at") {
+        return `${field} = $${index + 1}::timestamp`;
+      }
+      return `${field} = $${index + 1}`;
+    });
+    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, id) {
+    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, id) {
+    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() {
+    await this.pool.end();
+  }
+  /**
+   * Ensure store is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Map database row to DatabaseConfigEntry object
+   * Automatically decrypts password if present
+   */
+  mapRowToEntry(row) {
+    const config = typeof row.config === "string" ? JSON.parse(row.config) : row.config;
+    if (config.password) {
+      try {
+        config.password = (0, import_core.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 || void 0,
+      description: row.description || void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Encrypt password in config before storing
+   */
+  encryptPasswordInConfig(config) {
+    const configCopy = { ...config };
+    if (configCopy.password) {
+      configCopy.password = (0, import_core.encrypt)(configCopy.password);
+    }
+    return configCopy;
+  }
+};
+
+// src/stores/PostgreSQLWorkspaceStore.ts
+var import_pg6 = require("pg");
+
+// src/migrations/workspace_migrations.ts
+var createWorkspacesTable = {
+  version: 5,
+  name: "create_workspaces_table",
+  up: async (client) => {
+    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)
+      )
+    `);
+    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) => {
+    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");
+  }
+};
+
+// src/stores/PostgreSQLWorkspaceStore.ts
+var PostgreSQLWorkspaceStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new import_pg6.Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new import_pg6.Pool(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createWorkspacesTable);
+    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() {
+    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 Workspace object
+   */
+  mapRowToWorkspace(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      name: row.name,
+      description: row.description || void 0,
+      storageType: row.storage_type,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Get all workspaces for a tenant
+   */
+  async getAllWorkspaces(tenantId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, id, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ 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, id, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getWorkspaceById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+    const updateFields = [];
+    const updateValues = [];
+    let paramIndex = 1;
+    if (updates.name !== void 0) {
+      updateFields.push(`name = $${paramIndex++}`);
+      updateValues.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      updateFields.push(`description = $${paramIndex++}`);
+      updateValues.push(updates.description || null);
+    }
+    if (updates.storageType !== void 0) {
+      updateFields.push(`storage_type = $${paramIndex++}`);
+      updateValues.push(updates.storageType);
+    }
+    if (updateFields.length === 0) {
+      return existing;
+    }
+    updateFields.push(`updated_at = $${paramIndex++}`);
+    updateValues.push(/* @__PURE__ */ new Date());
+    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 await this.getWorkspaceById(tenantId, id);
+  }
+  /**
+   * Delete a workspace by ID
+   */
+  async deleteWorkspace(tenantId, id) {
+    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;
+  }
+};
+
+// src/stores/PostgreSQLProjectStore.ts
+var import_pg7 = require("pg");
+
+// src/migrations/project_migrations.ts
+var createProjectsTable = {
+  version: 6,
+  name: "create_projects_table",
+  up: async (client) => {
+    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)
+      )
+    `);
+    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) => {
+    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");
+  }
+};
+
+// src/stores/PostgreSQLProjectStore.ts
+var PostgreSQLProjectStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new import_pg7.Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new import_pg7.Pool(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createProjectsTable);
+    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() {
+    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 Project object
+   */
+  mapRowToProject(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      workspaceId: row.workspace_id,
+      name: row.name,
+      description: row.description || void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Get all projects for a specific workspace
+   */
+  async getProjectsByWorkspace(tenantId, workspaceId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      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, workspaceId, id, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ 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, id, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getProjectById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+    const updateFields = [];
+    const updateValues = [];
+    let paramIndex = 1;
+    if (updates.name !== void 0) {
+      updateFields.push(`name = $${paramIndex++}`);
+      updateValues.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      updateFields.push(`description = $${paramIndex++}`);
+      updateValues.push(updates.description || null);
+    }
+    if (updateFields.length === 0) {
+      return existing;
+    }
+    updateFields.push(`updated_at = $${paramIndex++}`);
+    updateValues.push(/* @__PURE__ */ new Date());
+    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 await this.getProjectById(tenantId, id);
+  }
+  /**
+   * Delete a project by ID
+   */
+  async deleteProject(tenantId, id) {
+    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;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MigrationManager,
   PostgreSQLAssistantStore,
+  PostgreSQLDatabaseConfigStore,
+  PostgreSQLProjectStore,
   PostgreSQLScheduleStorage,
   PostgreSQLSkillStore,
   PostgreSQLThreadStore,
+  PostgreSQLWorkspaceStore,
   createAssistantsTable,
+  createDatabaseConfigsTable,
+  createProjectsTable,
   createScheduledTasksTable,
   createSkillsTable,
-  createThreadsTable
+  createThreadsTable,
+  createWorkspacesTable
 });
 //# sourceMappingURL=index.js.map