@elysiumjs/mnemosyne 0.1.2 → 0.3.1

package/tests/model.test.ts

@@ -1,234 +0,0 @@
-// 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 { t } from 'elysia';
-
-import type { ColumnMetadata } from '../src/interfaces';
-
-import { createSchemaFromModel, AbstractModel } from '../src/model';
-
-// Hand-crafted column metadata for testing
-const userColumns: ColumnMetadata[] = [
-	{ name: 'id', dataType: 'uuid', nullable: false, hasDefault: true, isPrimaryKey: true },
-	{ name: 'name', dataType: 'string', nullable: false, hasDefault: false, isPrimaryKey: false },
-	{ name: 'age', dataType: 'number', nullable: false, hasDefault: false, isPrimaryKey: false },
-	{ name: 'email', dataType: 'string', nullable: false, hasDefault: false, isPrimaryKey: false },
-	{ name: 'is_confirmed', dataType: 'boolean', nullable: false, hasDefault: true, isPrimaryKey: false },
-];
-
-describe('Model', () => {
-	describe('createSchemaFromModel', () => {
-		it('should create a schema for select mode', () => {
-			const schema = createSchemaFromModel(userColumns, { mode: 'select' });
-
-			// Select mode should include all columns including primary key
-			expect(schema.properties).toBeDefined();
-			expect(schema.properties.id).toBeDefined();
-			expect(schema.properties.name).toBeDefined();
-			expect(schema.properties.age).toBeDefined();
-			expect(schema.properties.email).toBeDefined();
-			expect(schema.properties.is_confirmed).toBeDefined();
-		});
-
-		it('should create a schema for create mode', () => {
-			const schema = createSchemaFromModel(userColumns, { mode: 'create' });
-
-			// Create mode should exclude primary key
-			expect(schema.properties).toBeDefined();
-			expect(schema.properties.id).toBeUndefined();
-			expect(schema.properties.name).toBeDefined();
-			expect(schema.properties.age).toBeDefined();
-			expect(schema.properties.email).toBeDefined();
-			expect(schema.properties.is_confirmed).toBeDefined();
-		});
-
-		it('should create a schema for update mode', () => {
-			const schema = createSchemaFromModel(userColumns, { mode: 'update' });
-
-			// Update mode should exclude primary key
-			expect(schema.properties).toBeDefined();
-			expect(schema.properties.id).toBeUndefined();
-			expect(schema.properties.name).toBeDefined();
-			expect(schema.properties.age).toBeDefined();
-			expect(schema.properties.email).toBeDefined();
-			expect(schema.properties.is_confirmed).toBeDefined();
-		});
-
-		it('should make all fields optional in update mode', () => {
-			const columns: ColumnMetadata[] = [
-				{ name: 'id', dataType: 'uuid', nullable: false, hasDefault: true, isPrimaryKey: true },
-				{ name: 'name', dataType: 'string', nullable: false, hasDefault: false, isPrimaryKey: false },
-			];
-
-			const schema = createSchemaFromModel(columns, { mode: 'update' });
-
-			// In update mode, all non-PK fields should be optional (not required)
-			const required = schema.required ?? [];
-			expect(required).not.toContain('name');
-		});
-
-		it('should make fields with defaults optional in create mode', () => {
-			const columns: ColumnMetadata[] = [
-				{ name: 'id', dataType: 'uuid', nullable: false, hasDefault: true, isPrimaryKey: true },
-				{ name: 'status', dataType: 'string', nullable: false, hasDefault: true, isPrimaryKey: false },
-				{ name: 'name', dataType: 'string', nullable: false, hasDefault: false, isPrimaryKey: false },
-			];
-
-			const schema = createSchemaFromModel(columns, { mode: 'create' });
-
-			// 'status' has a default, so it should be optional
-			// 'name' does not have a default, so it should be required
-			expect(schema.properties.status).toBeDefined();
-			expect(schema.properties.name).toBeDefined();
-		});
-
-		it('should handle nullable columns', () => {
-			const columns: ColumnMetadata[] = [
-				{ name: 'bio', dataType: 'string', nullable: true, hasDefault: false, isPrimaryKey: false },
-			];
-
-			const schema = createSchemaFromModel(columns, { mode: 'select' });
-
-			// Nullable columns should be wrapped in t.Nullable
-			expect(schema.properties.bio).toBeDefined();
-		});
-
-		it('should return an empty object schema for empty columns', () => {
-			const schema = createSchemaFromModel([]);
-
-			// Should return t.Object({})
-			expect(schema.properties).toBeDefined();
-			expect(Object.keys(schema.properties)).toHaveLength(0);
-		});
-
-		it('should return an empty object schema for undefined columns', () => {
-			// @ts-expect-error Testing undefined input
-			const schema = createSchemaFromModel(undefined);
-
-			// Should return t.Object({})
-			expect(schema.properties).toBeDefined();
-			expect(Object.keys(schema.properties)).toHaveLength(0);
-		});
-
-		it('should handle all supported data types', () => {
-			const allTypeColumns: ColumnMetadata[] = [
-				{ name: 'col_string', dataType: 'string', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_uuid', dataType: 'uuid', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_number', dataType: 'number', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_boolean', dataType: 'boolean', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_array', dataType: 'array', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_json', dataType: 'json', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_date', dataType: 'date', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_datetime', dataType: 'datetime', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_bigint', dataType: 'bigint', nullable: false, hasDefault: false, isPrimaryKey: false },
-				{ name: 'col_buffer', dataType: 'buffer', nullable: false, hasDefault: false, isPrimaryKey: false },
-			];
-
-			const schema = createSchemaFromModel(allTypeColumns, { mode: 'select' });
-
-			// All data types should produce a valid schema property
-			expect(schema.properties.col_string).toBeDefined();
-			expect(schema.properties.col_uuid).toBeDefined();
-			expect(schema.properties.col_number).toBeDefined();
-			expect(schema.properties.col_boolean).toBeDefined();
-			expect(schema.properties.col_array).toBeDefined();
-			expect(schema.properties.col_json).toBeDefined();
-			expect(schema.properties.col_date).toBeDefined();
-			expect(schema.properties.col_datetime).toBeDefined();
-			expect(schema.properties.col_bigint).toBeDefined();
-			expect(schema.properties.col_buffer).toBeDefined();
-		});
-
-		it('should default to select mode when no mode is specified', () => {
-			const columns: ColumnMetadata[] = [
-				{ name: 'id', dataType: 'uuid', nullable: false, hasDefault: true, isPrimaryKey: true },
-				{ name: 'name', dataType: 'string', nullable: false, hasDefault: false, isPrimaryKey: false },
-			];
-
-			const schema = createSchemaFromModel(columns);
-
-			// Default mode should be 'select', which includes primary key
-			expect(schema.properties.id).toBeDefined();
-			expect(schema.properties.name).toBeDefined();
-		});
-	});
-
-	describe('AbstractModel', () => {
-		it('should create a model class with the correct properties', () => {
-			const mockAdapter = {
-				getTableName: () => 'users',
-				getColumns: () => userColumns,
-				createTenantTable: (table: any, tenant: string) => table,
-			};
-
-			const mockTable = { _tableName: 'users' };
-
-			class UserModel extends AbstractModel('users', { id: 'uuid', name: 'text' }, mockAdapter, mockTable) {}
-
-			// Check if the model class has the correct static properties
-			expect(UserModel.tableName).toBe('users');
-			expect(UserModel.columns).toEqual({ id: 'uuid', name: 'text' });
-			expect(UserModel.insertSchema).toBeDefined();
-			expect(UserModel.updateSchema).toBeDefined();
-			expect(UserModel.selectSchema).toBeDefined();
-			expect(UserModel.supportTenancy).toBe(false);
-			expect(UserModel.$inferSelect).toBeUndefined();
-			expect(UserModel.$inferInsert).toBeUndefined();
-			expect(UserModel.$inferUpdate).toBeUndefined();
-		});
-
-		it('should use the adapter to extract column metadata', () => {
-			const getColumnsSpy = { called: false };
-			const mockAdapter = {
-				getTableName: () => 'products',
-				getColumns: (table: any) => {
-					getColumnsSpy.called = true;
-					return [
-						{ name: 'id', dataType: 'uuid' as const, nullable: false, hasDefault: true, isPrimaryKey: true },
-						{ name: 'title', dataType: 'string' as const, nullable: false, hasDefault: false, isPrimaryKey: false },
-					];
-				},
-				createTenantTable: (table: any, tenant: string) => table,
-			};
-
-			const mockTable = { _tableName: 'products' };
-
-			class ProductModel extends AbstractModel('products', { id: 'uuid', title: 'text' }, mockAdapter, mockTable) {}
-
-			// The adapter's getColumns should have been called during model creation
-			expect(getColumnsSpy.called).toBe(true);
-
-			// Schemas should be generated from the adapter's column metadata
-			expect(ProductModel.insertSchema.properties.title).toBeDefined();
-			expect(ProductModel.insertSchema.properties.id).toBeUndefined(); // primary key excluded in create mode
-			expect(ProductModel.selectSchema.properties.id).toBeDefined(); // primary key included in select mode
-		});
-
-		it('should expose the table via the static table getter', () => {
-			const mockAdapter = {
-				getTableName: () => 'items',
-				getColumns: () => [],
-				createTenantTable: (table: any, tenant: string) => table,
-			};
-
-			const mockTable = { _tableName: 'items' };
-
-			class ItemModel extends AbstractModel('items', {}, mockAdapter, mockTable) {}
-
-			// The table getter should return the base table when not in a tenancy context
-			expect(ItemModel.table).toBe(mockTable);
-		});
-	});
-});

package/tests/repository.test.ts

@@ -1,177 +0,0 @@
-// 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, mock, spyOn } from 'bun:test';
-
-import { AbstractDatabase } from '../src/database';
-import { AbstractRepository } from '../src/repository';
-
-// Create a mock driver
-const mockDriver = {
-	createConnection: mock((config: any) => ({ mockConnection: true, config })),
-	withTransaction: mock((conn: any, cb: any) => cb(conn)),
-	getRawClient: mock((conn: any) => ({ rawClient: true })),
-};
-
-// Create a concrete database class for testing
-class TestDatabase extends AbstractDatabase<any, any> {
-	protected driver = mockDriver;
-}
-
-// Create a mock model
-const MockModel = {
-	$inferSelect: undefined as unknown,
-	$inferInsert: undefined as unknown,
-	$inferUpdate: undefined as unknown,
-	table: { _tableName: 'test_table' },
-	tableName: 'test_table',
-	columns: { id: 'uuid', name: 'text' },
-	insertSchema: {},
-	updateSchema: {},
-	selectSchema: {},
-	supportTenancy: false,
-} as any;
-
-describe('AbstractRepository', () => {
-	describe('Repository creation', () => {
-		it('should create a repository class with the correct model', () => {
-			const db = new TestDatabase();
-			const TestRepository = AbstractRepository(MockModel, db);
-
-			expect(TestRepository.Model).toBe(MockModel);
-		});
-
-		it('should set the default connection name', () => {
-			const db = new TestDatabase();
-			const TestRepository = AbstractRepository(MockModel, db);
-
-			expect(TestRepository.connection).toBe('default');
-		});
-	});
-
-	describe('Database connection', () => {
-		it('should get the database connection via the db getter', () => {
-			const db = new TestDatabase();
-			const mockConnection = { mockConnection: true };
-			const getConnectionSpy = spyOn(db, 'getConnection').mockReturnValue(mockConnection);
-
-			const TestRepository = AbstractRepository(MockModel, db);
-
-			// Create a concrete subclass since AbstractRepository returns an abstract class
-			class ConcreteRepository extends TestRepository {
-				public async all() { return []; }
-				public async paginate() { return { page: 1, data: [], total: 0 }; }
-				public async find() { return null; }
-				public async findBy() { return null; }
-				public async insert(data: any) { return data; }
-				public async update(id: any, data: any) { return data; }
-				public async updateAll(data: any) { return [data]; }
-				public async delete(id: any) { return {}; }
-				public async deleteAll() { return []; }
-				public async exists(id: any) { return false; }
-			}
-
-			const repo = new ConcreteRepository();
-			const connection = repo.db;
-
-			expect(getConnectionSpy).toHaveBeenCalledWith('default');
-			expect(connection).toBe(mockConnection);
-		});
-
-		it('should use a custom connection if specified', () => {
-			const db = new TestDatabase();
-			const mockConnection = { mockConnection: true };
-			const getConnectionSpy = spyOn(db, 'getConnection').mockReturnValue(mockConnection);
-
-			const TestRepository = AbstractRepository(MockModel, db);
-
-			// Create a concrete subclass with a custom connection
-			class CustomRepository extends TestRepository {
-				public static readonly connection = 'custom';
-				public async all() { return []; }
-				public async paginate() { return { page: 1, data: [], total: 0 }; }
-				public async find() { return null; }
-				public async findBy() { return null; }
-				public async insert(data: any) { return data; }
-				public async update(id: any, data: any) { return data; }
-				public async updateAll(data: any) { return [data]; }
-				public async delete(id: any) { return {}; }
-				public async deleteAll() { return []; }
-				public async exists(id: any) { return false; }
-			}
-
-			const repo = new CustomRepository();
-			const connection = repo.db;
-
-			expect(getConnectionSpy).toHaveBeenCalledWith('custom');
-			expect(connection).toBe(mockConnection);
-		});
-	});
-
-	describe('Abstract methods', () => {
-		it('should be subclassable with all CRUD methods implemented', () => {
-			const db = new TestDatabase();
-			const TestRepository = AbstractRepository(MockModel, db);
-
-			// Create a concrete subclass implementing all abstract methods
-			class ConcreteRepository extends TestRepository {
-				public async all() { return []; }
-				public async paginate() { return { page: 1, data: [], total: 0 }; }
-				public async find() { return null; }
-				public async findBy() { return null; }
-				public async insert(data: any) { return data; }
-				public async update(id: any, data: any) { return data; }
-				public async updateAll(data: any) { return [data]; }
-				public async delete(id: any) { return {}; }
-				public async deleteAll() { return []; }
-				public async exists(id: any) { return false; }
-			}
-
-			const repo = new ConcreteRepository();
-			expect(repo).toBeInstanceOf(ConcreteRepository);
-			expect(repo).toBeInstanceOf(TestRepository);
-		});
-
-		it('should have all required CRUD methods on the concrete subclass', () => {
-			const db = new TestDatabase();
-			const TestRepository = AbstractRepository(MockModel, db);
-
-			class ConcreteRepository extends TestRepository {
-				public async all() { return []; }
-				public async paginate() { return { page: 1, data: [], total: 0 }; }
-				public async find() { return null; }
-				public async findBy() { return null; }
-				public async insert(data: any) { return data; }
-				public async update(id: any, data: any) { return data; }
-				public async updateAll(data: any) { return [data]; }
-				public async delete(id: any) { return {}; }
-				public async deleteAll() { return []; }
-				public async exists(id: any) { return false; }
-			}
-
-			const repo = new ConcreteRepository();
-
-			expect(typeof repo.all).toBe('function');
-			expect(typeof repo.paginate).toBe('function');
-			expect(typeof repo.find).toBe('function');
-			expect(typeof repo.findBy).toBe('function');
-			expect(typeof repo.insert).toBe('function');
-			expect(typeof repo.update).toBe('function');
-			expect(typeof repo.updateAll).toBe('function');
-			expect(typeof repo.delete).toBe('function');
-			expect(typeof repo.deleteAll).toBe('function');
-			expect(typeof repo.exists).toBe('function');
-		});
-	});
-});

package/tests/setup.ts

@@ -1,26 +0,0 @@
-// 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 'reflect-metadata';
-
-import { mock } from 'bun:test';
-
-// Mock dependencies
-
-mock.module('node:async_hooks', () => ({
-	AsyncLocalStorage: class {
-		public run = mock((_map, callback) => callback());
-		public disable = mock();
-	}
-}));

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-	"extends": "../../tsconfig.base.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"declaration": true,
-		"emitDeclarationOnly": true,
-		"declarationMap": false,
-		"declarationDir": "dist",
-		"rootDir": "src"
-	},
-	"include": ["src"]
-}