@tstdl/base 0.93.182 → 0.93.184

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

@@ -1,178 +0,0 @@
-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 { describe, expect } from 'vitest';
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { StringProperty } from '../../schema/index.js';
-import { getIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { injectRepository } from '../server/repository.js';
-const schema = 'test_orm_edge_cases';
-const test = getIntegrationTest({ orm: { schema } });
-describe('ORM Repository 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);
-    test.beforeEach(async ({ database: db }) => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 ({ database: db }) => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        const repo = injectRepository(BaseItem);
-        await expect(repo.deleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
-    });
-    test('should throw NotFoundError when hardDelete target does not exist', 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 () => {
-        const repo = injectRepository(BaseItem);
-        await expect(repo.hardDeleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
-    });
-    test('should handle empty updates gracefully', 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 () => {
-        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 () => {
-        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

@@ -1,2 +0,0 @@
-/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
-export {};

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

@@ -1,140 +0,0 @@
-/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
-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 { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { Expires, Table, TimeToLive } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { TimestampProperty } from '../schemas/index.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Expiration', () => {
-    let injector;
-    let db;
-    let expirationRepo;
-    let ttlRepo;
-    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(100, 'hard') // 100ms TTL
-    ], TtlEntity);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        expirationRepo = injector.resolve(getRepository(ExpirationEntity));
-        ttlRepo = injector.resolve(getRepository(TtlEntity));
-        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`);
-        const e1 = await ttlRepo.insert(Object.assign(new TtlEntity(), { name: 'Valid' }));
-        // Wait 150ms for expiration
-        await new Promise((resolve) => setTimeout(resolve, 150));
-        await ttlRepo.processExpirations();
-        const all = await ttlRepo.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`);
-        const now = Date.now();
-        const past = now - 10000; // 10s ago
-        const future = now + 10000; // 10s in future
-        const e1 = await expirationRepo.insert(Object.assign(new ExpirationEntity(), { name: 'Expired', softExpireAt: past }));
-        const e2 = await expirationRepo.insert(Object.assign(new ExpirationEntity(), { name: 'Valid', softExpireAt: future }));
-        await expirationRepo.processExpirations();
-        const all = await expirationRepo.loadAll();
-        expect(all).toHaveLength(1);
-        expect(all[0].name).toBe('Valid');
-        const withDeleted = await expirationRepo.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`);
-        const now = Date.now();
-        const past = now - 10000;
-        const future = now + 10000;
-        const e1 = await expirationRepo.insert(Object.assign(new ExpirationEntity(), { name: 'Expired', hardExpireAt: past }));
-        const e2 = await expirationRepo.insert(Object.assign(new ExpirationEntity(), { name: 'Valid', hardExpireAt: future }));
-        await expirationRepo.processExpirations();
-        const all = await expirationRepo.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`);
-        const past = Date.now() - 10000;
-        await expirationRepo.insert(Object.assign(new ExpirationEntity(), {
-            name: 'BothExpired',
-            softExpireAt: past,
-            hardExpireAt: past,
-        }));
-        await expirationRepo.processExpirations();
-        const all = await expirationRepo.loadAll({ withDeleted: true });
-        expect(all).toHaveLength(0);
-    });
-});

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

@@ -1,2 +0,0 @@
-/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
-export {};