refactor: replace createDataSource with getDataSource for singleton database connection management

Author: Marvin Zhang

packages/core/src/entities/devlog-entry.entity.ts

@@ -77,8 +77,8 @@ export class DevlogEntryEntity {
   @Column({ type: 'varchar', length: 255, nullable: true })
   assignee?: string;
 
-  @Column({ type: 'int', nullable: true, name: 'project_id' })
-  projectId?: number;
+  @Column({ type: 'int', name: 'project_id' })
+  projectId!: number;
 
   // Flattened DevlogContext fields (simple strings and arrays)
   @Column({ type: 'text', nullable: true, name: 'business_context' })

packages/core/src/services/devlog-service.ts

@@ -17,7 +17,7 @@ import type {
   TimeSeriesStats,
 } from '../types/index.js';
 import { DevlogDependencyEntity, DevlogEntryEntity, DevlogNoteEntity } from '../entities/index.js';
-import { createDataSource } from '../utils/typeorm-config.js';
+import { getDataSource } from '../utils/typeorm-config.js';
 import { DevlogValidator } from '../validation/devlog-schemas.js';
 
 interface DevlogServiceInstance {
@@ -32,18 +32,29 @@ export class DevlogService {
   private devlogRepository: Repository<DevlogEntryEntity>;
 
   private constructor(private projectId?: number) {
-    this.database = createDataSource({
-      entities: [DevlogEntryEntity, DevlogNoteEntity, DevlogDependencyEntity],
-    });
-    this.devlogRepository = this.database.getRepository(DevlogEntryEntity);
+    // Database initialization will happen in ensureInitialized()
+    this.database = null as any; // Temporary placeholder
+    this.devlogRepository = null as any; // Temporary placeholder
   }
 
   /**
    * Initialize the database connection if not already initialized
    */
   private async ensureInitialized(): Promise<void> {
-    if (!this.database.isInitialized) {
-      await this.database.initialize();
+    try {
+      if (!this.database || !this.database.isInitialized) {
+        console.log('[DevlogService] Getting initialized DataSource...');
+        this.database = await getDataSource();
+        this.devlogRepository = this.database.getRepository(DevlogEntryEntity);
+        console.log(
+          '[DevlogService] DataSource ready with entities:',
+          this.database.entityMetadatas.length,
+        );
+        console.log('[DevlogService] Repository initialized:', !!this.devlogRepository);
+      }
+    } catch (error) {
+      console.error('[DevlogService] Failed to initialize:', error);
+      throw error;
     }
   }
 
@@ -69,7 +80,7 @@ export class DevlogService {
 
   async get(id: DevlogId): Promise<DevlogEntry | null> {
     await this.ensureInitialized();
-    
+
     // Validate devlog ID
     const idValidation = DevlogValidator.validateDevlogId(id);
     if (!idValidation.success) {
@@ -87,7 +98,7 @@ export class DevlogService {
 
   async save(entry: DevlogEntry): Promise<void> {
     await this.ensureInitialized();
-    
+
     // Validate devlog entry data
     const validation = DevlogValidator.validateDevlogEntry(entry);
     if (!validation.success) {
@@ -138,7 +149,7 @@ export class DevlogService {
 
   async delete(id: DevlogId): Promise<void> {
     await this.ensureInitialized();
-    
+
     // Validate devlog ID
     const idValidation = DevlogValidator.validateDevlogId(id);
     if (!idValidation.success) {
@@ -153,7 +164,7 @@ export class DevlogService {
 
   async list(filter?: DevlogFilter): Promise<PaginatedResult<DevlogEntry>> {
     await this.ensureInitialized();
-    
+
     // Validate filter if provided
     if (filter) {
       const filterValidation = DevlogValidator.validateFilter(filter);
@@ -174,7 +185,7 @@ export class DevlogService {
 
   async search(query: string, filter?: DevlogFilter): Promise<PaginatedResult<DevlogEntry>> {
     await this.ensureInitialized();
-    
+
     // Validate search query
     if (!query || typeof query !== 'string' || query.trim().length === 0) {
       throw new Error('Search query is required and must be a non-empty string');
@@ -206,7 +217,7 @@ export class DevlogService {
 
   async getStats(filter?: DevlogFilter): Promise<DevlogStats> {
     await this.ensureInitialized();
-    
+
     // Validate filter if provided
     if (filter) {
       const filterValidation = DevlogValidator.validateFilter(filter);
@@ -295,7 +306,7 @@ export class DevlogService {
     request?: TimeSeriesRequest,
   ): Promise<TimeSeriesStats> {
     await this.ensureInitialized();
-    
+
     // Calculate date range
     const days = request?.days || 30;
     const to = request?.to ? new Date(request.to) : new Date();
@@ -341,7 +352,7 @@ export class DevlogService {
 
   async getNextId(): Promise<DevlogId> {
     await this.ensureInitialized();
-    
+
     const result = await this.devlogRepository
       .createQueryBuilder('devlog')
       .select('MAX(devlog.id)', 'maxId')

packages/core/src/services/project-service.ts

@@ -8,18 +8,18 @@
 import { DataSource, Repository } from 'typeorm';
 import type { ProjectMetadata } from '../types/project.js';
 import { ProjectEntity } from '../entities/project.entity.js';
-import { createDataSource } from '../utils/typeorm-config.js';
+import { getDataSource } from '../utils/typeorm-config.js';
 import { ProjectValidator } from '../validation/project-schemas.js';
 
 export class ProjectService {
   private static instance: ProjectService | null = null;
   private database: DataSource;
   private repository: Repository<ProjectEntity>;
-  private initPromise: Promise<void> | null = null;
 
   constructor() {
-    this.database = createDataSource({ entities: [ProjectEntity] });
-    this.repository = this.database.getRepository(ProjectEntity);
+    // Database initialization will happen in ensureInitialized()
+    this.database = null as any; // Temporary placeholder
+    this.repository = null as any; // Temporary placeholder
   }
 
   static getInstance(): ProjectService {
@@ -29,23 +29,28 @@ export class ProjectService {
     return ProjectService.instance;
   }
 
-  async initialize(): Promise<void> {
-    if (this.initPromise) {
-      return this.initPromise; // Return existing initialization promise
+  /**
+   * Initialize the database connection if not already initialized
+   */
+  private async ensureInitialized(): Promise<void> {
+    try {
+      if (!this.database || !this.database.isInitialized) {
+        console.log('[ProjectService] Getting initialized DataSource...');
+        this.database = await getDataSource();
+        this.repository = this.database.getRepository(ProjectEntity);
+        console.log(
+          '[ProjectService] DataSource ready with entities:',
+          this.database.entityMetadatas.length,
+        );
+        console.log('[ProjectService] Repository initialized:', !!this.repository);
+
+        // Create default project if it doesn't exist
+        await this.createDefaultProject();
+      }
+    } catch (error) {
+      console.error('[ProjectService] Failed to initialize:', error);
+      throw error;
     }
-
-    this.initPromise = this._initialize();
-    return this.initPromise;
-  }
-
-  private async _initialize(): Promise<void> {
-    // Initialize the DataSource first
-    if (!this.database.isInitialized) {
-      await this.database.initialize();
-    }
-
-    // Create default project if it doesn't exist
-    await this.createDefaultProject();
   }
 
   /**
@@ -72,13 +77,17 @@ export class ProjectService {
   }
 
   async list(): Promise<ProjectMetadata[]> {
+    await this.ensureInitialized(); // Ensure initialization
+
     const entities = await this.repository.find({
       order: { lastAccessedAt: 'DESC' },
     });
     return entities.map((entity) => entity.toProjectMetadata());
   }
 
   async get(id: number): Promise<ProjectMetadata | null> {
+    await this.ensureInitialized(); // Ensure initialization
+
     const entity = await this.repository.findOne({ where: { id } });
 
     if (!entity) {
@@ -95,6 +104,8 @@ export class ProjectService {
   async create(
     project: Omit<ProjectMetadata, 'id' | 'createdAt' | 'lastAccessedAt'>,
   ): Promise<ProjectMetadata> {
+    await this.ensureInitialized(); // Ensure initialization
+
     // Validate input data
     const validation = ProjectValidator.validateCreateRequest(project);
     if (!validation.success) {
@@ -125,6 +136,8 @@ export class ProjectService {
   }
 
   async update(id: number, updates: Partial<ProjectMetadata>): Promise<ProjectMetadata> {
+    await this.ensureInitialized(); // Ensure initialization
+
     // Validate project ID
     const idValidation = ProjectValidator.validateProjectId(id);
     if (!idValidation.success) {
@@ -170,6 +183,8 @@ export class ProjectService {
   }
 
   async delete(id: number): Promise<void> {
+    await this.ensureInitialized(); // Ensure initialization
+
     // Validate project ID
     const idValidation = ProjectValidator.validateProjectId(id);
     if (!idValidation.success) {

packages/core/src/types/core.ts

@@ -180,7 +180,7 @@ export interface DevlogEntry {
   closedAt?: string; // ISO timestamp when status changed to 'done' or 'cancelled'
   assignee?: string;
   archived?: boolean; // For long-term management and performance
-  projectId?: number; // Project context for multi-project isolation
+  projectId: number; // Project context for multi-project isolation - REQUIRED
 
   // Flattened context fields
   acceptanceCriteria?: string[];

packages/core/src/utils/typeorm-config.ts

@@ -34,6 +34,49 @@ export interface TypeORMStorageOptions {
   ssl?: boolean;
 }
 
+// Singleton DataSource instance
+let singletonDataSource: DataSource | null = null;
+let initializationPromise: Promise<DataSource> | null = null;
+
+/**
+ * Get or create the singleton DataSource instance
+ * All services should use this to ensure they share the same database connection
+ * Handles race conditions by ensuring only one initialization happens
+ */
+export async function getDataSource(): Promise<DataSource> {
+  if (singletonDataSource?.isInitialized) {
+    return singletonDataSource;
+  }
+
+  // If initialization is already in progress, wait for it
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+
+  // Start initialization
+  initializationPromise = (async () => {
+    if (!singletonDataSource) {
+      console.log('[DataSource] Creating singleton DataSource instance...');
+      const options = parseTypeORMConfig();
+      singletonDataSource = createDataSource({ options });
+    }
+
+    // Initialize the DataSource if not already initialized
+    if (!singletonDataSource.isInitialized) {
+      console.log('[DataSource] Initializing singleton DataSource...');
+      await singletonDataSource.initialize();
+      console.log(
+        '[DataSource] Singleton DataSource initialized with entities:',
+        singletonDataSource.entityMetadatas.length,
+      );
+    }
+
+    return singletonDataSource;
+  })();
+
+  return initializationPromise;
+}
+
 /**
  * Create TypeORM DataSource based on storage options
  * Uses caching to prevent duplicate connections in development
@@ -63,6 +106,8 @@ export function createDataSource({
     logging: options.logging ?? false,
   };
 
+  console.log('[DataSource] Creating DataSource with', baseConfig.entities?.length, 'entities');
+
   let config: DataSourceOptions;
 
   switch (options.type) {