@tstdl/base 0.93.87 → 0.93.90

package/orm/tests/repository-edge-cases.test.js

@@ -0,0 +1,216 @@
+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 { NotFoundError } from '../../errors/not-found.error.js';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { ChildEntity, Column, Inheritance, 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 Edge Cases', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_edge_cases';
+    let BaseItem = class BaseItem extends Entity {
+        type;
+        name;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'type' }),
+        __metadata("design:type", String)
+    ], BaseItem.prototype, "type", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], BaseItem.prototype, "name", void 0);
+    BaseItem = __decorate([
+        Table('base_items', { schema }),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], BaseItem);
+    let DerivedItem = class DerivedItem extends BaseItem {
+        description;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], DerivedItem.prototype, "description", void 0);
+    DerivedItem = __decorate([
+        Table('derived_items', { schema }),
+        ChildEntity('derived')
+    ], DerivedItem);
+    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('derived_items')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('base_items')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('base_items')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type TEXT NOT NULL,
+        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 '{}',
+        UNIQUE (id, type)
+      )
+    `);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('derived_items')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'derived'),
+        description TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('base_items')} (id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should rollback transaction on insertMany failure', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            const id = '00000000-0000-0000-0000-000000000001';
+            try {
+                await repo.insertMany([
+                    Object.assign(new BaseItem(), { id, name: 'Success', type: 'base' }),
+                    Object.assign(new BaseItem(), { id, name: 'Fail', type: 'base' }) // Duplicate ID
+                ]);
+            }
+            catch {
+                // Expected
+            }
+            const count = await repo.count();
+            expect(count).toBe(0);
+        });
+    });
+    test('should rollback transaction on updateMany failure', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await repo.insert(Object.assign(new BaseItem(), { name: 'Item 1', type: 'base' }));
+            try {
+                await repo.transaction(async (tx) => {
+                    const txRepo = repo.withTransaction(tx);
+                    await txRepo.updateManyByQuery({}, { name: 'Updated' });
+                    throw new Error('Rollback');
+                });
+            }
+            catch {
+                // Expected
+            }
+            const item = await repo.loadByQuery({ name: 'Item 1' });
+            expect(item.name).toBe('Item 1');
+        });
+    });
+    test('should throw on negative offset', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.loadAll({ offset: -1 })).rejects.toThrow();
+        });
+    });
+    test('should fail when unique constraint is violated even if soft deleted', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            const id = '00000000-0000-0000-0000-000000000002';
+            await repo.insert(Object.assign(new BaseItem(), { id, name: 'A', type: 'base' }));
+            await repo.delete(id);
+            // Attempt to insert same ID again (Unique violation)
+            await expect(repo.insert(Object.assign(new BaseItem(), { id, name: 'B', type: 'base' }))).rejects.toThrow();
+        });
+    });
+    test('should fail loading if child row is missing (data corruption)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const derivedRepo = injectRepository(DerivedItem);
+            const baseRepo = injectRepository(BaseItem);
+            const derived = await derivedRepo.insert(Object.assign(new DerivedItem(), { name: 'Derived', description: 'Desc' }));
+            // Manually delete child row
+            await db.execute(sql `DELETE FROM ${sql.identifier(schema)}.${sql.identifier('derived_items')} WHERE id = ${derived.id}`);
+            // Verify deletion
+            const { rows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('derived_items')} WHERE id = ${derived.id}`);
+            expect(rows).toHaveLength(0);
+            // Child repo should fail because primary table row is missing
+            await expect(derivedRepo.load(derived.id)).rejects.toThrow(NotFoundError);
+            // Base repo should succeed (returning corrupted entity) because base row exists and it uses left join for subclasses
+            const loadedBase = await baseRepo.load(derived.id, { includeSubclasses: true });
+            expect(loadedBase).toBeInstanceOf(DerivedItem);
+            expect(loadedBase.description).toBeNull();
+        });
+    });
+    test('should throw NotFoundError when update target does not exist', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.update('00000000-0000-0000-0000-000000000000', { name: 'New' })).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should throw NotFoundError when updateByQuery matches nothing', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.updateByQuery({ name: 'Missing' }, { name: 'New' })).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should throw NotFoundError when delete target does not exist', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.delete('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should throw NotFoundError when deleteByQuery matches nothing', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.deleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should throw NotFoundError when hardDelete target does not exist', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.hardDelete('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should throw NotFoundError when hardDeleteByQuery matches nothing', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.hardDeleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should handle empty updates gracefully', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            const item = await repo.insert(Object.assign(new BaseItem(), { name: 'EmptyUpdate', type: 'base' }));
+            const updated = await repo.update(item.id, {});
+            expect(updated.metadata.revision).toBeGreaterThan(item.metadata.revision);
+            expect(updated.name).toBe('EmptyUpdate');
+        });
+    });
+    test('should handle unknown properties in query gracefully (throw error)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            await expect(repo.loadByQuery({ unknownProp: 'value' })).rejects.toThrow('Could not map property unknownProp');
+        });
+    });
+    test('should prevent updating discriminator column via update', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(BaseItem);
+            const item = await repo.insert(Object.assign(new BaseItem(), { name: 'TypeCheck', type: 'base' }));
+            // Try to change type to 'derived'
+            await repo.update(item.id, { type: 'derived' });
+            const reloaded = await repo.load(item.id);
+            // It should change if not blocked
+            expect(reloaded.type).toBe('derived');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,153 @@
+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 { Expires, Table, TimeToLive } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { TimestampProperty } from '../schemas/index.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Expiration', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_expiration';
+    let ExpirationEntity = class ExpirationEntity extends Entity {
+        name;
+        softExpireAt;
+        hardExpireAt;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], ExpirationEntity.prototype, "name", void 0);
+    __decorate([
+        TimestampProperty(),
+        Expires({ after: 0, mode: 'soft' }),
+        __metadata("design:type", Number)
+    ], ExpirationEntity.prototype, "softExpireAt", void 0);
+    __decorate([
+        TimestampProperty(),
+        Expires({ after: 0, mode: 'hard' }),
+        __metadata("design:type", Number)
+    ], ExpirationEntity.prototype, "hardExpireAt", void 0);
+    ExpirationEntity = __decorate([
+        Table('expiration_entities', { schema })
+    ], ExpirationEntity);
+    let TtlEntity = class TtlEntity extends Entity {
+        name;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], TtlEntity.prototype, "name", void 0);
+    TtlEntity = __decorate([
+        Table('ttl_entities', { schema }),
+        TimeToLive(1000, 'hard') // 1s TTL
+    ], TtlEntity);
+    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('expiration_entities')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('ttl_entities')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('expiration_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name TEXT NOT NULL,
+        soft_expire_at TIMESTAMP WITH TIME ZONE,
+        hard_expire_at TIMESTAMP WITH TIME ZONE,
+        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 '{}'
+      )
+    `);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('ttl_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 support TimeToLive decorator', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('ttl_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(TtlEntity);
+            const e1 = await repository.insert(Object.assign(new TtlEntity(), { name: 'Valid' }));
+            // Wait 1.1s for expiration
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            await repository.processExpirations();
+            const all = await repository.loadAll({ withDeleted: true });
+            expect(all).toHaveLength(0);
+        });
+    });
+    test('should soft delete expired entities', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('expiration_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ExpirationEntity);
+            const now = Date.now();
+            const past = now - 10000; // 10s ago
+            const future = now + 10000; // 10s in future
+            const e1 = await repository.insert(Object.assign(new ExpirationEntity(), { name: 'Expired', softExpireAt: past }));
+            const e2 = await repository.insert(Object.assign(new ExpirationEntity(), { name: 'Valid', softExpireAt: future }));
+            await repository.processExpirations();
+            const all = await repository.loadAll();
+            expect(all).toHaveLength(1);
+            expect(all[0].name).toBe('Valid');
+            const withDeleted = await repository.loadAll({ withDeleted: true });
+            expect(withDeleted).toHaveLength(2);
+            expect(withDeleted.find((e) => e.id === e1.id).metadata.deleteTimestamp).toBeDefined();
+        });
+    });
+    test('should hard delete expired entities', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('expiration_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ExpirationEntity);
+            const now = Date.now();
+            const past = now - 10000;
+            const future = now + 10000;
+            const e1 = await repository.insert(Object.assign(new ExpirationEntity(), { name: 'Expired', hardExpireAt: past }));
+            const e2 = await repository.insert(Object.assign(new ExpirationEntity(), { name: 'Valid', hardExpireAt: future }));
+            await repository.processExpirations();
+            const all = await repository.loadAll({ withDeleted: true });
+            expect(all).toHaveLength(1);
+            expect(all[0].name).toBe('Valid');
+        });
+    });
+    test('should handle mixed expiration', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('expiration_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ExpirationEntity);
+            const past = Date.now() - 10000;
+            await repository.insert(Object.assign(new ExpirationEntity(), {
+                name: 'BothExpired',
+                softExpireAt: past,
+                hardExpireAt: past,
+            }));
+            await repository.processExpirations();
+            const all = await repository.loadAll({ withDeleted: true });
+            expect(all).toHaveLength(0);
+        });
+    });
+});

package/orm/tests/repository-extra-coverage.test.d.ts

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