@inkeep/agents-core 0.41.2 → 0.43.0

package/dist/data-access/manage/projectLifecycle.d.ts

@@ -0,0 +1,119 @@
+import { PaginationConfig, PaginationResult, ProjectModels } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { StopWhen } from "../../validation/schemas.js";
+import { ProjectMetadataSelect } from "../../types/entities.js";
+
+//#region src/data-access/manage/projectLifecycle.d.ts
+interface CreateProjectWithBranchParams {
+  tenantId: string;
+  projectId: string;
+  createdBy?: string;
+}
+interface CreateProjectWithBranchResult {
+  id: string;
+  tenantId: string;
+  mainBranchName: string;
+  createdAt: string;
+  createdBy: string | null;
+}
+interface DeleteProjectWithBranchParams {
+  tenantId: string;
+  projectId: string;
+}
+/**
+ * Generate the main branch name for a project
+ */
+declare function getProjectMainBranchName(tenantId: string, projectId: string): string;
+/**
+ * Create a project with its main branch
+ *
+ * This utility:
+ * 1. Creates the project record in the runtime DB (source of truth for existence)
+ * 2. Creates the project main branch in the config DB (Doltgres)
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const createProjectMetadataAndBranch: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: CreateProjectWithBranchParams) => Promise<CreateProjectWithBranchResult>;
+/**
+ * Delete a project and its branch
+ *
+ * This utility:
+ * 1. Gets the project from runtime DB to find the branch name
+ * 2. Deletes the project branch from config DB (Doltgres)
+ * 3. Deletes the project record from runtime DB
+ *
+ * Note: Callers should handle cascade deletion of runtime entities (conversations, etc.)
+ * before calling this function.
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const deleteProjectWithBranch: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: DeleteProjectWithBranchParams) => Promise<boolean>;
+/**
+ * Get project with branch info
+ *
+ * Returns the project from runtime DB including the main branch name
+ */
+declare const getProjectWithBranchInfo: (runDb: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<ProjectMetadataSelect | null>;
+/**
+ * Project metadata from the versioned config DB
+ */
+interface ProjectConfigMetadata {
+  name: string;
+  description: string | null;
+  models: ProjectModels | null;
+  stopWhen: StopWhen | null;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * Combined project data from runtime + config DBs
+ */
+interface ProjectWithMetadata {
+  id: string;
+  tenantId: string;
+  createdAt: string;
+  createdBy: string | null;
+  mainBranchName: string;
+  name: string | null;
+  description: string | null;
+  models: ProjectModels | null;
+  stopWhen: StopWhen | null;
+  configUpdatedAt: string | null;
+}
+interface ListProjectsWithMetadataResult {
+  data: ProjectWithMetadata[];
+  pagination: PaginationResult;
+}
+/**
+ * List projects with metadata from both runtime and config DBs
+ *
+ * This function:
+ * 1. Gets the list of projects from runtime DB (source of truth for existence)
+ * 2. For each project, queries the config DB at the project's main branch to get metadata
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const listProjectsWithMetadataPaginated: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  pagination?: PaginationConfig;
+  projectIds?: string[];
+}) => Promise<ListProjectsWithMetadataResult>;
+/**
+ * Get a single project with metadata from both runtime and config DBs
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const getProjectWithMetadata: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<ProjectWithMetadata | null>;
+//#endregion
+export { CreateProjectWithBranchParams, CreateProjectWithBranchResult, DeleteProjectWithBranchParams, ListProjectsWithMetadataResult, ProjectConfigMetadata, ProjectWithMetadata, createProjectMetadataAndBranch, deleteProjectWithBranch, getProjectMainBranchName, getProjectWithBranchInfo, getProjectWithMetadata, listProjectsWithMetadataPaginated };

package/dist/data-access/manage/projectLifecycle.js

@@ -0,0 +1,234 @@
+import { getLogger } from "../../utils/logger.js";
+import { doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch } from "../../dolt/branch.js";
+import { createProjectMetadata, deleteProjectMetadata, getProjectMetadata, listProjectsMetadataPaginated } from "../runtime/projects.js";
+import { sql } from "drizzle-orm";
+
+//#region src/data-access/manage/projectLifecycle.ts
+const logger = getLogger("project-lifecycle");
+/**
+* Generate the main branch name for a project
+*/
+function getProjectMainBranchName(tenantId, projectId) {
+	return `${tenantId}_${projectId}_main`;
+}
+/**
+* Create a project with its main branch
+*
+* This utility:
+* 1. Creates the project record in the runtime DB (source of truth for existence)
+* 2. Creates the project main branch in the config DB (Doltgres)
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const createProjectMetadataAndBranch = (runDb, configDb) => async (params) => {
+	const { tenantId, projectId, createdBy } = params;
+	const mainBranchName = getProjectMainBranchName(tenantId, projectId);
+	logger.info({
+		tenantId,
+		projectId,
+		mainBranchName
+	}, "Creating project with branch");
+	const runtimeProject = await createProjectMetadata(runDb)({
+		id: projectId,
+		tenantId,
+		createdBy: createdBy ?? null,
+		mainBranchName
+	});
+	logger.debug({ projectId }, "Created project in runtime DB");
+	try {
+		if (!await doltBranchExists(configDb)({ name: mainBranchName })) {
+			await doltBranch(configDb)({ name: mainBranchName });
+			logger.debug({ mainBranchName }, "Created project main branch");
+		}
+	} catch (error) {
+		logger.error({
+			error,
+			mainBranchName
+		}, "Failed to create project branch, rolling back");
+		await deleteProjectMetadata(runDb)({
+			tenantId,
+			projectId
+		});
+		throw error;
+	}
+	logger.info({
+		tenantId,
+		projectId,
+		mainBranchName
+	}, "Successfully created project with branch");
+	return {
+		id: runtimeProject.id,
+		tenantId: runtimeProject.tenantId,
+		mainBranchName: runtimeProject.mainBranchName,
+		createdAt: runtimeProject.createdAt,
+		createdBy: runtimeProject.createdBy
+	};
+};
+/**
+* Delete a project and its branch
+*
+* This utility:
+* 1. Gets the project from runtime DB to find the branch name
+* 2. Deletes the project branch from config DB (Doltgres)
+* 3. Deletes the project record from runtime DB
+*
+* Note: Callers should handle cascade deletion of runtime entities (conversations, etc.)
+* before calling this function.
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const deleteProjectWithBranch = (runDb, configDb) => async (params) => {
+	const { tenantId, projectId } = params;
+	logger.info({
+		tenantId,
+		projectId
+	}, "Deleting project with branch");
+	const project = await getProjectMetadata(runDb)({
+		tenantId,
+		projectId
+	});
+	if (!project) {
+		logger.warn({
+			tenantId,
+			projectId
+		}, "Project not found in runtime DB");
+		return false;
+	}
+	const { mainBranchName } = project;
+	try {
+		await doltCheckout(configDb)({ branch: "main" });
+		await doltDeleteBranch(configDb)({
+			name: mainBranchName,
+			force: true
+		});
+		logger.info({ mainBranchName }, "Deleted project branch");
+	} catch (error) {
+		logger.error({
+			error,
+			mainBranchName
+		}, "Failed to delete project branch, continuing with runtime cleanup");
+	}
+	const deleted = await deleteProjectMetadata(runDb)({
+		tenantId,
+		projectId
+	});
+	if (deleted) logger.info({
+		tenantId,
+		projectId,
+		mainBranchName
+	}, "Successfully deleted project with branch");
+	else logger.warn({
+		tenantId,
+		projectId
+	}, "Failed to delete project from runtime DB");
+	return deleted;
+};
+/**
+* Get project with branch info
+*
+* Returns the project from runtime DB including the main branch name
+*/
+const getProjectWithBranchInfo = (runDb) => async (params) => {
+	return await getProjectMetadata(runDb)(params);
+};
+/**
+* Get project metadata from config DB at a specific branch using AS OF syntax
+*
+* This queries the projects table without checking out the branch
+*/
+async function getProjectMetadataFromBranch(configDb, branchName, tenantId, projectId) {
+	try {
+		const result = await configDb.execute(sql.raw(`
+        SELECT name, description, models, stop_when, created_at, updated_at
+        FROM projects AS OF '${branchName}'
+        WHERE tenant_id = '${tenantId}' AND id = '${projectId}'
+        LIMIT 1
+      `));
+		if (result.rows.length === 0) return null;
+		const row = result.rows[0];
+		return {
+			name: row.name,
+			description: row.description,
+			models: row.models,
+			stopWhen: row.stop_when,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at
+		};
+	} catch (error) {
+		logger.warn({
+			error,
+			branchName,
+			tenantId,
+			projectId
+		}, "Failed to get project metadata from branch");
+		return null;
+	}
+}
+/**
+* List projects with metadata from both runtime and config DBs
+*
+* This function:
+* 1. Gets the list of projects from runtime DB (source of truth for existence)
+* 2. For each project, queries the config DB at the project's main branch to get metadata
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const listProjectsWithMetadataPaginated = (runDb, configDb) => async (params) => {
+	const { tenantId, pagination, projectIds } = params;
+	const projectMetadataResult = await listProjectsMetadataPaginated(runDb)({
+		tenantId,
+		pagination,
+		projectIds
+	});
+	return {
+		data: await Promise.all(projectMetadataResult.data.map(async (projectMetadata) => {
+			const metadata = await getProjectMetadataFromBranch(configDb, projectMetadata.mainBranchName, tenantId, projectMetadata.id);
+			return {
+				id: projectMetadata.id,
+				tenantId: projectMetadata.tenantId,
+				createdAt: projectMetadata.createdAt,
+				createdBy: projectMetadata.createdBy,
+				mainBranchName: projectMetadata.mainBranchName,
+				name: metadata?.name ?? null,
+				description: metadata?.description ?? null,
+				models: metadata?.models ?? null,
+				stopWhen: metadata?.stopWhen ?? null,
+				configUpdatedAt: metadata?.updatedAt ?? null
+			};
+		})),
+		pagination: projectMetadataResult.pagination
+	};
+};
+/**
+* Get a single project with metadata from both runtime and config DBs
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const getProjectWithMetadata = (runDb, configDb) => async (params) => {
+	const { tenantId, projectId } = params;
+	const runtimeProject = await getProjectMetadata(runDb)({
+		tenantId,
+		projectId
+	});
+	if (!runtimeProject) return null;
+	const metadata = await getProjectMetadataFromBranch(configDb, runtimeProject.mainBranchName, tenantId, projectId);
+	return {
+		id: runtimeProject.id,
+		tenantId: runtimeProject.tenantId,
+		createdAt: runtimeProject.createdAt,
+		createdBy: runtimeProject.createdBy,
+		mainBranchName: runtimeProject.mainBranchName,
+		name: metadata?.name ?? null,
+		description: metadata?.description ?? null,
+		models: metadata?.models ?? null,
+		stopWhen: metadata?.stopWhen ?? null,
+		configUpdatedAt: metadata?.updatedAt ?? null
+	};
+};
+
+//#endregion
+export { createProjectMetadataAndBranch, deleteProjectWithBranch, getProjectMainBranchName, getProjectWithBranchInfo, getProjectWithMetadata, listProjectsWithMetadataPaginated };

package/dist/data-access/manage/projects.d.ts

@@ -0,0 +1,75 @@
+import { PaginationConfig, PaginationResult, ProjectInfo, ProjectResourceCounts, ProjectScopeConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { ProjectInsert, ProjectSelect, ProjectUpdate } from "../../types/entities.js";
+
+//#region src/data-access/manage/projects.d.ts
+
+/**
+ * List all unique project IDs within a tenant by scanning all resource tables
+ * @param projectIds - Optional array of project IDs to filter by. If undefined, returns all projects.
+ */
+declare const listProjects: (db: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  projectIds?: string[];
+}) => Promise<ProjectInfo[]>;
+/**
+ * List all unique project IDs within a tenant with pagination
+ * Optionally filter by a list of project IDs (for access control)
+ */
+declare const listProjectsPaginated: (db: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  pagination?: PaginationConfig;
+  projectIds?: string[];
+}) => Promise<{
+  data: ProjectSelect[];
+  pagination: PaginationResult;
+}>;
+/**
+ * Get resource counts for a specific project
+ */
+declare const getProjectResourceCounts: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<ProjectResourceCounts>;
+/**
+ * Check if a project exists (has any resources)
+ */
+declare const projectExists: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<boolean>;
+/**
+ * Count total projects for a tenant
+ */
+declare const countProjects: (db: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+}) => Promise<number>;
+/**
+ * Get a single project by ID
+ */
+declare const getProject: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<ProjectSelect | null>;
+/**
+ * Create a new project
+ */
+declare const createProject: (db: AgentsManageDatabaseClient) => (params: ProjectInsert) => Promise<ProjectSelect>;
+/**
+ * Update an existing project
+ */
+declare const updateProject: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  data: ProjectUpdate;
+}) => Promise<ProjectSelect | null>;
+/**
+ * Check if a project exists in the projects table
+ */
+declare const projectExistsInTable: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<boolean>;
+/**
+ * Check if a project has any resources (used before deletion)
+ */
+declare const projectHasResources: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<boolean>;
+/**
+ * Delete a project (with validation for existing resources)
+ */
+declare const deleteProject: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<boolean>;
+//#endregion
+export { countProjects, createProject, deleteProject, getProject, getProjectResourceCounts, listProjects, listProjectsPaginated, projectExists, projectExistsInTable, projectHasResources, updateProject };

package/dist/data-access/{projects.js → manage/projects.js}

@@ -1,12 +1,15 @@
-import { agents, artifactComponents, contextCache, contextConfigs, conversations, credentialReferences, dataComponents, externalAgents, ledgerArtifacts, messages, projects, subAgentArtifactComponents, subAgentDataComponents, subAgentRelations, subAgentToolRelations, subAgents, taskRelations, tasks, tools } from "../db/schema.js";
-import { and, count, desc, eq } from "drizzle-orm";
+import { agents, artifactComponents, contextConfigs, credentialReferences, dataComponents, externalAgents, projects, subAgentArtifactComponents, subAgentDataComponents, subAgentRelations, subAgentToolRelations, subAgents, tools } from "../../db/manage/manage-schema.js";
+import { and, count, desc, eq, inArray } from "drizzle-orm";
 
-//#region src/data-access/projects.ts
+//#region src/data-access/manage/projects.ts
 /**
 * List all unique project IDs within a tenant by scanning all resource tables
+* @param projectIds - Optional array of project IDs to filter by. If undefined, returns all projects.
 */
 const listProjects = (db) => async (params) => {
-	const projectsFromTable = await db.select({ projectId: projects.id }).from(projects).where(eq(projects.tenantId, params.tenantId));
+	if (params.projectIds !== void 0 && params.projectIds.length === 0) return [];
+	const whereClause = params.projectIds ? and(eq(projects.tenantId, params.tenantId), inArray(projects.id, params.projectIds)) : eq(projects.tenantId, params.tenantId);
+	const projectsFromTable = await db.select({ projectId: projects.id }).from(projects).where(whereClause);
 	if (projectsFromTable.length > 0) return projectsFromTable.map((p) => ({ projectId: p.projectId }));
 	const projectIdSets = await Promise.all([
 		db.selectDistinct({ projectId: subAgents.projectId }).from(subAgents).where(eq(subAgents.tenantId, params.tenantId)),
@@ -20,30 +23,28 @@ const listProjects = (db) => async (params) => {
 		db.selectDistinct({ projectId: subAgentArtifactComponents.projectId }).from(subAgentArtifactComponents).where(eq(subAgentArtifactComponents.tenantId, params.tenantId)),
 		db.selectDistinct({ projectId: dataComponents.projectId }).from(dataComponents).where(eq(dataComponents.tenantId, params.tenantId)),
 		db.selectDistinct({ projectId: artifactComponents.projectId }).from(artifactComponents).where(eq(artifactComponents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: tasks.projectId }).from(tasks).where(eq(tasks.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: taskRelations.projectId }).from(taskRelations).where(eq(taskRelations.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: conversations.projectId }).from(conversations).where(eq(conversations.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: messages.projectId }).from(messages).where(eq(messages.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: contextCache.projectId }).from(contextCache).where(eq(contextCache.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: credentialReferences.projectId }).from(credentialReferences).where(eq(credentialReferences.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: ledgerArtifacts.projectId }).from(ledgerArtifacts).where(eq(ledgerArtifacts.tenantId, params.tenantId))
+		db.selectDistinct({ projectId: credentialReferences.projectId }).from(credentialReferences).where(eq(credentialReferences.tenantId, params.tenantId))
 	]);
 	const allProjectIds = /* @__PURE__ */ new Set();
 	projectIdSets.forEach((results) => {
 		results.forEach((row) => {
-			if (row.projectId) allProjectIds.add(row.projectId);
+			if (row.projectId) {
+				if (!params.projectIds || params.projectIds.includes(row.projectId)) allProjectIds.add(row.projectId);
+			}
 		});
 	});
 	return Array.from(allProjectIds).sort().map((projectId) => ({ projectId }));
 };
 /**
 * List all unique project IDs within a tenant with pagination
+* Optionally filter by a list of project IDs (for access control)
 */
 const listProjectsPaginated = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = params.pagination?.limit || 10;
 	const offset = (page - 1) * limit;
-	const [data, totalResult] = await Promise.all([db.select().from(projects).where(eq(projects.tenantId, params.tenantId)).limit(limit).offset(offset).orderBy(desc(projects.createdAt)), db.select({ count: count() }).from(projects).where(eq(projects.tenantId, params.tenantId))]);
+	const whereClause = params.projectIds ? and(eq(projects.tenantId, params.tenantId), inArray(projects.id, params.projectIds)) : eq(projects.tenantId, params.tenantId);
+	const [data, totalResult] = await Promise.all([db.select().from(projects).where(whereClause).limit(limit).offset(offset).orderBy(desc(projects.createdAt)), db.select({ count: count() }).from(projects).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -85,9 +86,7 @@ const projectExists = (db) => async (params) => {
 		db.select({ id: agents.id }).from(agents).where(whereClause(agents)).limit(1),
 		db.select({ id: tools.id }).from(tools).where(whereClause(tools)).limit(1),
 		db.select({ id: contextConfigs.id }).from(contextConfigs).where(whereClause(contextConfigs)).limit(1),
-		db.select({ id: externalAgents.id }).from(externalAgents).where(whereClause(externalAgents)).limit(1),
-		db.select({ id: tasks.id }).from(tasks).where(whereClause(tasks)).limit(1),
-		db.select({ id: conversations.id }).from(conversations).where(whereClause(conversations)).limit(1)
+		db.select({ id: externalAgents.id }).from(externalAgents).where(whereClause(externalAgents)).limit(1)
 	];
 	return (await Promise.all(checks)).some((result) => result.length > 0);
 };