@tstdl/base 0.93.87 → 0.93.90

package/orm/tests/repository-soft-delete.test.js

@@ -0,0 +1,143 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Soft Delete (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_soft_delete';
+    let SoftDeleteEntity = class SoftDeleteEntity extends Entity {
+        name;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], SoftDeleteEntity.prototype, "name", void 0);
+    SoftDeleteEntity = __decorate([
+        Table('soft_delete_entities', { schema })
+    ], SoftDeleteEntity);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
+            }
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name TEXT NOT NULL,
+        revision INTEGER NOT NULL,
+        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        delete_timestamp TIMESTAMP WITH TIME ZONE,
+        attributes JSONB NOT NULL DEFAULT '{}'
+      )
+    `);
+    });
+    test('should soft delete an entity by ID', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+            const deleted = await repository.delete(e1.id);
+            expect(deleted.id).toBe(e1.id);
+            expect(deleted.metadata.deleteTimestamp).toBeDefined();
+            expect(await repository.has(e1.id)).toBe(false);
+            expect(await repository.tryLoad(e1.id)).toBeUndefined();
+            expect(await repository.count()).toBe(0);
+            const allWithDeleted = await repository.loadAll({ withDeleted: true });
+            expect(allWithDeleted).toHaveLength(1);
+            expect(allWithDeleted[0].id).toBe(e1.id);
+        });
+    });
+    test('should soft delete multiple entities by IDs', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+            const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
+            const deleted = await repository.deleteMany([e1.id, e2.id]);
+            expect(deleted).toHaveLength(2);
+            expect(await repository.count()).toBe(0);
+            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(2);
+        });
+    });
+    test('should soft delete entities by query', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            await repository.insertMany([
+                Object.assign(new SoftDeleteEntity(), { name: 'A' }),
+                Object.assign(new SoftDeleteEntity(), { name: 'B' }),
+                Object.assign(new SoftDeleteEntity(), { name: 'A' }),
+            ]);
+            const deleted = await repository.deleteManyByQuery({ name: 'A' });
+            expect(deleted).toHaveLength(2);
+            expect(await repository.count()).toBe(1);
+            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(3);
+        });
+    });
+    test('should not update soft-deleted entities by default', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+            await repository.delete(e1.id);
+            const updated = await repository.tryUpdate(e1.id, { name: 'Updated' });
+            expect(updated).toBeUndefined();
+            const loaded = await repository.tryLoad(e1.id, { withDeleted: true });
+            expect(loaded.name).toBe('E1');
+        });
+    });
+    test('should support hard delete on soft-deleted entities', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+            await repository.delete(e1.id);
+            const hardDeleted = await repository.hardDelete(e1.id);
+            expect(hardDeleted.id).toBe(e1.id);
+            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
+        });
+    });
+    test('should ignore already soft-deleted entities when deleting again', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+            await repository.delete(e1.id);
+            const secondDelete = await repository.tryDelete(e1.id);
+            expect(secondDelete).toBeUndefined();
+        });
+    });
+    test('should hard delete multiple entities by query (including soft-deleted)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SoftDeleteEntity);
+            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+            const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
+            await repository.delete(e1.id); // Soft delete E1
+            const hardDeleted = await repository.hardDeleteManyByQuery({});
+            expect(hardDeleted).toHaveLength(2); // Should hard delete both
+            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
+        });
+    });
+});

package/orm/tests/repository-transactions-nested.test.d.ts

@@ -0,0 +1 @@
+export {};

package/orm/tests/repository-transactions-nested.test.js

@@ -0,0 +1,202 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Transactions Nested (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_tx_nested';
+    let TxEntity = class TxEntity extends Entity {
+        name;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], TxEntity.prototype, "name", void 0);
+    TxEntity = __decorate([
+        Table('tx_entities', { schema })
+    ], TxEntity);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
+            },
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name TEXT NOT NULL,
+        revision INTEGER NOT NULL,
+        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        delete_timestamp TIMESTAMP WITH TIME ZONE,
+        attributes JSONB NOT NULL DEFAULT '{}'
+      )
+    `);
+    });
+    test('should commit nested transaction', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            await repo.transaction(async (tx1) => {
+                const repo1 = repo.withTransaction(tx1);
+                await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
+                await repo1.transaction(async (tx2) => {
+                    const repo2 = repo1.withTransaction(tx2);
+                    await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                });
+            });
+            const count = await repo.count();
+            expect(count).toBe(2);
+        });
+    });
+    test('should rollback nested transaction (inner fails)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            try {
+                await repo.transaction(async (tx1) => {
+                    const repo1 = repo.withTransaction(tx1);
+                    await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
+                    await repo1.transaction(async (tx2) => {
+                        const repo2 = repo1.withTransaction(tx2);
+                        await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                        throw new Error('Fail Inner');
+                    });
+                });
+            }
+            catch (e) {
+                expect(e.message).toBe('Fail Inner');
+            }
+            const count = await repo.count();
+            expect(count).toBe(0); // Outer should rollback too if error propagates
+        });
+    });
+    test('should rollback nested transaction but keep outer if caught', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            await repo.transaction(async (tx1) => {
+                const repo1 = repo.withTransaction(tx1);
+                await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
+                try {
+                    await repo1.transaction(async (tx2) => {
+                        const repo2 = repo1.withTransaction(tx2);
+                        await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                        throw new Error('Fail Inner');
+                    });
+                }
+                catch {
+                    // Swallow error to keep outer alive
+                }
+            });
+            const all = await repo.loadAll();
+            expect(all).toHaveLength(1);
+            expect(all[0].name).toBe('Outer');
+        });
+    });
+    test('should rollback outer transaction (outer fails after inner commit)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            try {
+                await repo.transaction(async (tx1) => {
+                    const repo1 = repo.withTransaction(tx1);
+                    await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
+                    await repo1.transaction(async (tx2) => {
+                        const repo2 = repo1.withTransaction(tx2);
+                        await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                    });
+                    throw new Error('Fail Outer');
+                });
+            }
+            catch {
+                // Expected
+            }
+            const count = await repo.count();
+            expect(count).toBe(0);
+        });
+    });
+    test('should support multiple nested transactions sequentially', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            await repo.transaction(async (tx1) => {
+                const repo1 = repo.withTransaction(tx1);
+                await repo1.transaction(async (tx2) => {
+                    await repo1.withTransaction(tx2).insert(Object.assign(new TxEntity(), { name: 'Inner1' }));
+                });
+                await repo1.transaction(async (tx3) => {
+                    await repo1.withTransaction(tx3).insert(Object.assign(new TxEntity(), { name: 'Inner2' }));
+                });
+            });
+            const count = await repo.count();
+            expect(count).toBe(2);
+        });
+    });
+    test('should support deep nesting (3 levels)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            await repo.transaction(async (tx1) => {
+                const r1 = repo.withTransaction(tx1);
+                await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
+                await r1.transaction(async (tx2) => {
+                    const r2 = r1.withTransaction(tx2);
+                    await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
+                    await r2.transaction(async (tx3) => {
+                        const r3 = r2.withTransaction(tx3);
+                        await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
+                    });
+                });
+            });
+            const count = await repo.count();
+            expect(count).toBe(3);
+        });
+    });
+    test('should rollback deep nesting middle layer', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TxEntity);
+            await repo.transaction(async (tx1) => {
+                const r1 = repo.withTransaction(tx1);
+                await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
+                try {
+                    await r1.transaction(async (tx2) => {
+                        const r2 = r1.withTransaction(tx2);
+                        await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
+                        await r2.transaction(async (tx3) => {
+                            const r3 = r2.withTransaction(tx3);
+                            await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
+                        });
+                        throw new Error('Fail L2');
+                    });
+                }
+                catch {
+                    // Catch L2 failure
+                }
+            });
+            const all = await repo.loadAll();
+            expect(all).toHaveLength(1);
+            expect(all[0].name).toBe('L1');
+        });
+    });
+});

package/orm/tests/repository-types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/orm/tests/repository-types.test.js

@@ -0,0 +1,218 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { Array, BooleanProperty, Integer, NumberProperty, string, StringProperty } from '../../schema/index.js';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { JsonProperty, NumericDateProperty, TimestampProperty } from '../schemas/index.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Types (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_types';
+    let TypeEntity = class TypeEntity extends Entity {
+        text;
+        int;
+        float;
+        bool;
+        numericDate;
+        timestamp;
+        json;
+        tags;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], TypeEntity.prototype, "text", void 0);
+    __decorate([
+        Integer(),
+        __metadata("design:type", Number)
+    ], TypeEntity.prototype, "int", void 0);
+    __decorate([
+        NumberProperty(),
+        __metadata("design:type", Number)
+    ], TypeEntity.prototype, "float", void 0);
+    __decorate([
+        BooleanProperty(),
+        __metadata("design:type", Boolean)
+    ], TypeEntity.prototype, "bool", void 0);
+    __decorate([
+        NumericDateProperty(),
+        __metadata("design:type", Number)
+    ], TypeEntity.prototype, "numericDate", void 0);
+    __decorate([
+        TimestampProperty(),
+        __metadata("design:type", Date)
+    ], TypeEntity.prototype, "timestamp", void 0);
+    __decorate([
+        JsonProperty(),
+        __metadata("design:type", Object)
+    ], TypeEntity.prototype, "json", void 0);
+    __decorate([
+        Array(string()),
+        __metadata("design:type", Array)
+    ], TypeEntity.prototype, "tags", void 0);
+    TypeEntity = __decorate([
+        Table('type_entities', { schema })
+    ], TypeEntity);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
+            },
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('type_entities')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('type_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        text TEXT NOT NULL,
+        int INTEGER NOT NULL,
+        float DOUBLE PRECISION NOT NULL,
+        bool BOOLEAN NOT NULL,
+        numeric_date DATE NOT NULL,
+        timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        json JSONB NOT NULL,
+        tags TEXT[] NOT NULL,
+        revision INTEGER NOT NULL,
+        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        delete_timestamp TIMESTAMP WITH TIME ZONE,
+        attributes JSONB NOT NULL DEFAULT '{}'
+      )
+    `);
+    });
+    test('should persist and retrieve boolean values (true)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 't', int: 1, float: 1.1, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.bool).toBe(true);
+        });
+    });
+    test('should persist and retrieve boolean values (false)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'f', int: 1, float: 1.1, bool: false, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.bool).toBe(false);
+        });
+    });
+    test('should persist and retrieve integer boundaries', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const maxInt = 2147483647;
+            const minInt = -2147483648;
+            const e1 = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'max', int: maxInt, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const l1 = await repo.load(e1.id);
+            expect(l1.int).toBe(maxInt);
+            const e2 = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'min', int: minInt, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const l2 = await repo.load(e2.id);
+            expect(l2.int).toBe(minInt);
+        });
+    });
+    test('should persist and retrieve float precision', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const pi = 3.1415926535;
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'pi', int: 0, float: pi, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.float).toBeCloseTo(pi);
+        });
+    });
+    test('should persist and retrieve numeric dates', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const today = 19723; // 2024-01-01
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'date', int: 0, float: 0, bool: true, numericDate: today, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.numericDate).toBe(today);
+        });
+    });
+    test('should persist and retrieve timestamps', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const now = new Date();
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'ts', int: 0, float: 0, bool: true, numericDate: 0, timestamp: now, json: {}, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            // Postgres stores microsecond precision, JS Date has millisecond.
+            // Drizzle custom type returns number (milliseconds).
+            // We accept a small difference due to precision loss or round-trip.
+            expect(typeof loaded.timestamp).toBe('number');
+            expect(Math.abs(loaded.timestamp - now.getTime())).toBeLessThan(2);
+        });
+    });
+    test('should persist and retrieve complex JSON', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const data = {
+                foo: 'bar',
+                nested: { a: 1, b: [true, false] },
+                nullVal: null,
+            };
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'json', int: 0, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: data, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.json).toEqual(data);
+        });
+    });
+    test('should persist and retrieve arrays', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const tags = ['a', 'b', 'c'];
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'array', int: 0, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags,
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.tags).toEqual(tags);
+        });
+    });
+    test('should persist and retrieve empty arrays', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            const entity = await repo.insert(Object.assign(new TypeEntity(), {
+                text: 'empty-array', int: 0, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }));
+            const loaded = await repo.load(entity.id);
+            expect(loaded.tags).toEqual([]);
+        });
+    });
+    test('should fail on integer overflow', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(TypeEntity);
+            // Max int is 2147483647
+            const overflow = 3000000000;
+            await expect(repo.insert(Object.assign(new TypeEntity(), {
+                text: 'overflow', int: overflow, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
+            }))).rejects.toThrow(); // Postgres should reject
+        });
+    });
+});

package/orm/tests/schema-converter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/orm/tests/schema-converter.test.js

@@ -0,0 +1,81 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { StringProperty } from '../../schema/index.js';
+import { getTableConfig } from 'drizzle-orm/pg-core';
+import { describe, expect, test } from 'vitest';
+import { Column, Index, PrimaryKeyProperty, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { getDrizzleTableFromType } from '../server/drizzle/schema-converter.js';
+let Parent = class Parent extends Entity {
+    code;
+};
+__decorate([
+    StringProperty(),
+    Column({ name: 'code' }),
+    __metadata("design:type", String)
+], Parent.prototype, "code", void 0);
+Parent = __decorate([
+    Table('parent_table', { schema: 'test' })
+], Parent);
+describe('ORM Schema Generation - Detailed Configurations', () => {
+    test('should generate partial index with where clause', () => {
+        let PartialIndexEntity = class PartialIndexEntity extends Entity {
+            status;
+        };
+        __decorate([
+            StringProperty(),
+            Index({ where: () => ({ status: 'active' }) }),
+            __metadata("design:type", String)
+        ], PartialIndexEntity.prototype, "status", void 0);
+        PartialIndexEntity = __decorate([
+            Table('partial_index_test', { schema: 'test' })
+        ], PartialIndexEntity);
+        const table = getDrizzleTableFromType(PartialIndexEntity);
+        const config = getTableConfig(table);
+        expect(config.indexes.length).toBeGreaterThan(0);
+        const idx = config.indexes[0];
+        expect(idx).toBeDefined();
+        expect(idx.config.where).toBeDefined();
+    });
+    test('should handle index with nulls ordering', () => {
+        let NullOrderingEntity = class NullOrderingEntity extends Entity {
+            val;
+        };
+        __decorate([
+            StringProperty(),
+            Index({ nulls: 'first' }),
+            __metadata("design:type", String)
+        ], NullOrderingEntity.prototype, "val", void 0);
+        NullOrderingEntity = __decorate([
+            Table('null_ordering_test', { schema: 'test' })
+        ], NullOrderingEntity);
+        const table = getDrizzleTableFromType(NullOrderingEntity);
+        const config = getTableConfig(table);
+        expect(config.indexes.length).toBeGreaterThan(0);
+    });
+    test('should handle renamed id column', () => {
+        let RenamedIdEntity = class RenamedIdEntity extends Entity {
+        };
+        __decorate([
+            StringProperty(),
+            Column({ name: 'custom_id' }),
+            PrimaryKeyProperty(),
+            __metadata("design:type", String)
+        ], RenamedIdEntity.prototype, "id", void 0);
+        RenamedIdEntity = __decorate([
+            Table('renamed_id_test', { schema: 'test' })
+        ], RenamedIdEntity);
+        const table = getDrizzleTableFromType(RenamedIdEntity);
+        const config = getTableConfig(table);
+        const idCol = config.columns.find(c => c.name === 'custom_id');
+        expect(idCol).toBeDefined();
+        expect(idCol.primary).toBe(true);
+    });
+});

package/orm/tests/schema-generation.test.d.ts

@@ -0,0 +1 @@
+export {};