@elysiumjs/mnemosyne-drizzle 0.1.3 → 0.2.0

package/tests/migrations.test.ts

@@ -0,0 +1,123 @@
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { describe, expect, it } from 'bun:test';
+
+import { getMigrationName, planMigrations } from '../src/migrations';
+
+const dir = '/app/src/database/migrations';
+
+// Records applied after every migration in these tests was generated.
+const applied = (...names: string[]) =>
+	names.map((name) => ({ name, appliedAt: new Date('2027-01-01T00:00:00Z') }));
+
+describe('getMigrationName', () => {
+	it('should use the file name of a flat migration', () => {
+		expect(getMigrationName(`${dir}/0000_users.sql`)).toBe('0000_users.sql');
+	});
+
+	it('should use the folder name of a Drizzle Kit 1.0 migration', () => {
+		expect(getMigrationName(`${dir}/20260101120000_users/migration.sql`)).toBe(
+			'20260101120000_users'
+		);
+	});
+});
+
+describe('planMigrations', () => {
+	it('should run every migration on an empty database, in order', () => {
+		const files = [
+			`${dir}/20260102000000_posts/migration.sql`,
+			`${dir}/20260101000000_users/migration.sql`
+		];
+
+		expect(planMigrations(files, applied())).toEqual({
+			pending: [
+				`${dir}/20260101000000_users/migration.sql`,
+				`${dir}/20260102000000_posts/migration.sql`
+			],
+			renames: []
+		});
+	});
+
+	it('should skip migrations already applied under their current name', () => {
+		const files = [`${dir}/0000_users.sql`, `${dir}/20260101000000_posts/migration.sql`];
+
+		expect(planMigrations(files, applied('0000_users.sql', '20260101000000_posts'))).toEqual({
+			pending: [],
+			renames: []
+		});
+	});
+
+	it('should recognise flat migrations that drizzle-kit up moved into folders', () => {
+		const files = [
+			`${dir}/20250301101500_users/migration.sql`,
+			`${dir}/20250302090000_posts/migration.sql`,
+			`${dir}/20260101000000_comments/migration.sql`
+		];
+
+		expect(planMigrations(files, applied('0000_users.sql', '0001_posts.sql'))).toEqual({
+			pending: [`${dir}/20260101000000_comments/migration.sql`],
+			renames: [
+				{ from: '0000_users.sql', to: '20250301101500_users' },
+				{ from: '0001_posts.sql', to: '20250302090000_posts' }
+			]
+		});
+	});
+
+	it('should match timestamp-prefixed flat migrations whose prefix differs from the folder', () => {
+		const files = [`${dir}/20250301101501_add_users_table/migration.sql`];
+
+		expect(planMigrations(files, applied('20250301101459_add_users_table.sql'))).toEqual({
+			pending: [],
+			renames: [
+				{ from: '20250301101459_add_users_table.sql', to: '20250301101501_add_users_table' }
+			]
+		});
+	});
+
+	it('should pair repeated names in order', () => {
+		const files = [
+			`${dir}/20250301000000_update/migration.sql`,
+			`${dir}/20250302000000_update/migration.sql`,
+			`${dir}/20250303000000_update/migration.sql`
+		];
+
+		expect(planMigrations(files, applied('0000_update.sql', '0001_update.sql'))).toEqual({
+			pending: [`${dir}/20250303000000_update/migration.sql`],
+			renames: [
+				{ from: '0000_update.sql', to: '20250301000000_update' },
+				{ from: '0001_update.sql', to: '20250302000000_update' }
+			]
+		});
+	});
+
+	it('should not move a record whose flat file is still there', () => {
+		const files = [`${dir}/0000_users.sql`, `${dir}/20260101000000_users/migration.sql`];
+
+		expect(planMigrations(files, applied('0000_users.sql'))).toEqual({
+			pending: [`${dir}/20260101000000_users/migration.sql`],
+			renames: []
+		});
+	});
+
+	it('should run a new migration that reuses the name of a deleted one', () => {
+		const files = [`${dir}/20260101000000_update/migration.sql`];
+		const records = [{ name: '0003_update.sql', appliedAt: new Date('2025-06-01T00:00:00Z') }];
+
+		expect(planMigrations(files, records)).toEqual({
+			pending: [`${dir}/20260101000000_update/migration.sql`],
+			renames: []
+		});
+	});
+});

package/tests/setup.ts

@@ -1,10 +0,0 @@
-import 'reflect-metadata';
-
-import { mock } from 'bun:test';
-
-mock.module('node:async_hooks', () => ({
-	AsyncLocalStorage: class {
-		public run = mock((_map, callback) => callback());
-		public disable = mock();
-	}
-}));

package/tsconfig.json

@@ -3,10 +3,10 @@
 	"compilerOptions": {
 		"outDir": "dist",
 		"declaration": true,
-		"emitDeclarationOnly": true,
 		"declarationMap": false,
 		"declarationDir": "dist",
-		"rootDir": "src"
+		"rootDir": "src",
+		"allowImportingTsExtensions": false
 	},
 	"include": ["src"]
 }

package/bunfig.toml

@@ -1,11 +0,0 @@
-[test]
-root = "./tests"
-preload = ["./tests/setup.ts"]
-coverage = true
-coverageThreshold = { line = 0.9, function = 0.7, statement = 0.8 }
-coverageSkipTestFiles = true
-coverageReporter = ["lcov", "text"]
-coverageDir = "./coverage"
-
-[run]
-bun = true

package/tests/database.test.ts

@@ -1,198 +0,0 @@
-// Copyright (c) 2026-present Workbud Technologies Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, jest, mock, spyOn } from 'bun:test';
-
-import { Application, Service } from '@elysiumjs/core';
-
-import { Database } from '../src/database';
-
-// Mock drizzle function
-mock.module('drizzle-orm/bun-sql', () => ({
-	drizzle: mock(() => ({ mockDrizzleInstance: true }))
-}));
-
-describe('DrizzleDatabase', () => {
-	// Mock console.error and process.exit to prevent actual console output and process exit
-	const originalConsoleError = console.error;
-	const originalProcessExit = process.exit;
-
-	beforeAll(() => {
-		// Mock Application.context so that getConnection('default') works
-		const mockContext = {
-			getStore: mock(() => new Map())
-		};
-		Object.defineProperty(Application, 'context', {
-			get: () => mockContext,
-			configurable: true
-		});
-	});
-
-	beforeEach(() => {
-		console.error = mock();
-		process.exit = mock() as any;
-	});
-
-	afterEach(() => {
-		console.error = originalConsoleError;
-		process.exit = originalProcessExit;
-		jest.clearAllMocks();
-	});
-
-	afterAll(() => {
-		mock.restore();
-	});
-
-	describe('registerConnection', () => {
-		it('should register a new connection', () => {
-			// Mock Service.exists to return false (connection doesn't exist)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(false);
-			const instanceSpy = spyOn(Service, 'instance');
-
-			// Call the function
-			const result = Database.registerConnection('test', { connection: 'sqlite:test.db' });
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if Service.instance was called with the correct parameters
-			expect(instanceSpy).toHaveBeenCalledWith('db.connection.test', {
-				mockDrizzleInstance: true
-			});
-
-			// Check if the result is correct
-			expect(result as any).toEqual({ mockDrizzleInstance: true });
-		});
-
-		it('should exit if the connection already exists', () => {
-			// Mock Service.exists to return true (connection exists)
-			spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Call the function
-			Database.registerConnection('test', { connection: 'sqlite:test.db' });
-
-			// Check if console.error and process.exit were called
-			expect(console.error).toHaveBeenCalledWith(
-				expect.stringContaining('A connection with the name test has already been registered')
-			);
-			expect(process.exit).toHaveBeenCalledWith(1);
-		});
-	});
-
-	describe('getConnection', () => {
-		it('should retrieve an existing connection', () => {
-			// Mock Service.exists to return true (connection exists)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Mock Service.get to return a mock connection
-			const mockConnection = { mockConnection: true };
-			const getSpy = spyOn(Service, 'get').mockReturnValue(mockConnection);
-
-			// Call the function
-			const result = Database.getConnection('test');
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if Service.get was called with the correct connection name
-			expect(getSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
-		});
-
-		it('should exit if the connection does not exist', () => {
-			// Mock Service.exists to return false (connection doesn't exist)
-			spyOn(Service, 'exists').mockReturnValueOnce(false);
-
-			// Call the function
-			Database.getConnection('test');
-
-			// Check if console.error and process.exit were called
-			expect(console.error).toHaveBeenCalledWith(
-				expect.stringContaining('No connection with name test found')
-			);
-			expect(process.exit).toHaveBeenCalledWith(1);
-		});
-	});
-
-	describe('connectionExists', () => {
-		it('should return true if the connection exists', () => {
-			// Mock Service.exists to return true
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Call the function
-			const result = Database.connectionExists('test');
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the result is correct
-			expect(result).toBe(true);
-		});
-
-		it('should return false if the connection does not exist', () => {
-			// Mock Service.exists to return false
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(false);
-
-			// Call the function
-			const result = Database.connectionExists('test');
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the result is correct
-			expect(result).toBe(false);
-		});
-	});
-
-	describe('getDefaultConnection', () => {
-		it('should retrieve the default connection', () => {
-			// Mock Service to return the mock connection
-			const mockConnection = { mockConnection: true };
-			spyOn(Service, 'exists').mockReturnValueOnce(true);
-			spyOn(Service, 'get').mockReturnValue(mockConnection);
-
-			// Call the function
-			const result = Database.getDefaultConnection();
-
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
-		});
-	});
-
-	describe('setDefaultConnection', () => {
-		it('should set the default connection', () => {
-			const instanceSpy = spyOn(Service, 'instance');
-			const removeSpy = spyOn(Service, 'remove');
-			spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Mock Service.get to return a mock connection
-			const mockConnection = { mockConnection: true };
-			spyOn(Service, 'get').mockReturnValue(mockConnection);
-
-			// Call the function
-			const result = Database.setDefaultConnection('test');
-
-			// Check if Service.remove was called with the correct connection name
-			expect(removeSpy).toHaveBeenCalledWith('db.connection.default');
-
-			// Check if Service.instance was called with the correct parameters
-			expect(instanceSpy).toHaveBeenCalledWith('db.connection.default', mockConnection);
-
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
-		});
-	});
-});