@tstdl/base 0.93.181 → 0.93.183

package/orm/tests/repository-extra-coverage.test.js

@@ -1,402 +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, beforeEach, describe, expect, test } from 'vitest';
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
-import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
-import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
-import { BaseEntity, Entity } from '../entity.js';
-import { getRepository } from '../server/repository.js';
-describe('ORM Repository Extra Coverage', () => {
-    let injector;
-    let database;
-    let baseItemRepo;
-    let premiumItemRepo;
-    let simpleItemRepo;
-    let plainItemRepo;
-    const schema = 'test_orm_extra_coverage';
-    let BaseItem = class BaseItem extends Entity {
-        type;
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'type' }),
-        __metadata("design:type", String)
-    ], BaseItem.prototype, "type", void 0);
-    __decorate([
-        StringProperty(),
-        Column({ name: 'name' }),
-        __metadata("design:type", String)
-    ], BaseItem.prototype, "name", void 0);
-    BaseItem = __decorate([
-        Table('items', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], BaseItem);
-    let PremiumItem = class PremiumItem extends BaseItem {
-        code;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'code' }),
-        __metadata("design:type", String)
-    ], PremiumItem.prototype, "code", void 0);
-    PremiumItem = __decorate([
-        Table('premium_items', { schema }),
-        ChildEntity('premium')
-    ], PremiumItem);
-    let SimpleItem = class SimpleItem extends Entity {
-        label;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'label' }),
-        __metadata("design:type", String)
-    ], SimpleItem.prototype, "label", void 0);
-    SimpleItem = __decorate([
-        Table('simple_items', { schema })
-    ], SimpleItem);
-    let PlainItem = class PlainItem extends BaseEntity {
-        description;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'description' }),
-        __metadata("design:type", String)
-    ], PlainItem.prototype, "description", void 0);
-    PlainItem = __decorate([
-        Table('plain_items', { schema })
-    ], PlainItem);
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
-        baseItemRepo = injector.resolve(getRepository(BaseItem));
-        premiumItemRepo = injector.resolve(getRepository(PremiumItem));
-        simpleItemRepo = injector.resolve(getRepository(SimpleItem));
-        plainItemRepo = injector.resolve(getRepository(PlainItem));
-        await dropTables(database, schema, ['premium_items', 'items', 'simple_items', 'plain_items']);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('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 database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('premium_items')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'premium'),
-        code TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('items')} (id, type) ON DELETE CASCADE
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('simple_items')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        label TEXT NOT NULL UNIQUE,
-        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 database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('plain_items')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        description TEXT NOT NULL
-      )
-    `);
-    });
-    beforeEach(async () => {
-        await truncateTables(database, schema, ['premium_items', 'items', 'simple_items', 'plain_items']);
-    });
-    test('loadManyCursor should work', async () => {
-        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Cursor Test' }));
-        const cursor = simpleItemRepo.loadManyCursor([item.id]);
-        const results = await toArrayAsync(cursor);
-        expect(results).toHaveLength(1);
-        expect(results[0].id).toBe(item.id);
-    });
-    test('loadAllCursor should work', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'All Cursor Test' }));
-        const cursor = simpleItemRepo.loadAllCursor();
-        const results = await toArrayAsync(cursor);
-        expect(results.length).toBeGreaterThan(0);
-    });
-    test('tryLoadByQuery with order option', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'A' }));
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'B' }));
-        const item = await simpleItemRepo.tryLoadByQuery({}, { order: { label: 'desc' } });
-        expect(item.label).toBe('B');
-    });
-    test('insertManyIfNotExists with empty array', async () => {
-        const results = await simpleItemRepo.insertManyIfNotExists(['label'], []);
-        expect(results).toHaveLength(0);
-    });
-    test('insertManyIfNotExists with items', async () => {
-        const item = Object.assign(new SimpleItem(), { label: 'Unique' });
-        const results = await simpleItemRepo.insertManyIfNotExists(['label'], [item]);
-        expect(results).toHaveLength(1);
-        const results2 = await simpleItemRepo.insertManyIfNotExists(['label'], [item]);
-        expect(results2).toHaveLength(0);
-    });
-    test('tryInsert returning entity', async () => {
-        const item = Object.assign(new SimpleItem(), { label: 'TryInsert' });
-        const inserted = await simpleItemRepo.tryInsert(item);
-        expect(inserted).toBeDefined();
-        expect(inserted.label).toBe('TryInsert');
-        const conflict = await simpleItemRepo.tryInsert(inserted); // Should conflict on ID
-        expect(conflict).toBeUndefined();
-    });
-    test('loadMany with empty array', async () => {
-        const results = await simpleItemRepo.loadMany([]);
-        expect(results).toHaveLength(0);
-    });
-    test('insertMany for non-CTI with empty array', async () => {
-        const results = await simpleItemRepo.insertMany([]);
-        expect(results).toHaveLength(0);
-    });
-    test('countByQuery returning count', async () => {
-        const initialCount = await simpleItemRepo.count();
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Count Test' }));
-        const newCount = await simpleItemRepo.count();
-        expect(newCount).toBe(initialCount + 1);
-    });
-    test('mapManyToColumns and mapManyToInsertColumns', async () => {
-        const item = Object.assign(new SimpleItem(), { label: 'Map Test' });
-        const cols = await simpleItemRepo.mapManyToColumns([item]);
-        expect(cols).toHaveLength(1);
-        expect(cols[0].label).toBe('Map Test');
-        const insertCols = await simpleItemRepo.mapManyToInsertColumns([item]);
-        expect(insertCols).toHaveLength(1);
-        expect(insertCols[0].label).toBe('Map Test');
-    });
-    test('tryUpsert on non-CTI returning undefined when condition fails', async () => {
-        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Upsert Condition' }));
-        const conflictItem = Object.assign(new SimpleItem(), { id: item.id, label: 'Should Fail' });
-        const result = await simpleItemRepo.tryUpsert(['id'], conflictItem, undefined, { set: { label: 'Impossible' } });
-        expect(result).toBeUndefined();
-    });
-    test('tryUpdateByQuery on non-CTI', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'UpdateByQuery' }));
-        const result = await simpleItemRepo.tryUpdateByQuery({ label: 'UpdateByQuery' }, { label: 'UpdatedByQuery' });
-        expect(result).toBeDefined();
-        expect(result.label).toBe('UpdatedByQuery');
-        const result2 = await simpleItemRepo.tryUpdateByQuery({ label: 'Ghost' }, { label: 'Buster' });
-        expect(result2).toBeUndefined();
-    });
-    test('tryDeleteByQuery on CTI', async () => {
-        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'DeleteMe', code: 'D1' }));
-        const result = await premiumItemRepo.tryDeleteByQuery({ name: 'DeleteMe' });
-        expect(result).toBeDefined();
-        expect(result.metadata.deleteTimestamp).not.toBeNull();
-        const result2 = await premiumItemRepo.tryDeleteByQuery({ name: 'Ghost' });
-        expect(result2).toBeUndefined();
-    });
-    test('getIdLimitQuery for update', async () => {
-        const query = simpleItemRepo.getIdLimitQuery({ label: 'Any' }).for('update');
-        expect(query).toBeDefined();
-    });
-    test('applySelect with distinct and distinctOn', async () => {
-        const q1 = simpleItemRepo.applySelect(database, true);
-        expect(q1).toBeDefined();
-        const q2 = simpleItemRepo.applySelect(database, ['label']);
-        expect(q2).toBeDefined();
-    });
-    test('mapToColumns and mapToInsertColumns', async () => {
-        const item = Object.assign(new SimpleItem(), { label: 'Map Single' });
-        const col = await simpleItemRepo.mapToColumns(item);
-        expect(col.label).toBe('Map Single');
-        const insertCol = await simpleItemRepo.mapToInsertColumns(item);
-        expect(insertCol.label).toBe('Map Single');
-    });
-    test('hasAll with duplicates and missing IDs', async () => {
-        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'HasAll' }));
-        expect(await simpleItemRepo.hasAll([item.id, item.id])).toBe(true);
-        expect(await simpleItemRepo.hasAll([item.id, '00000000-0000-0000-0000-000000000000'])).toBe(false);
-        expect(await simpleItemRepo.hasAll([])).toBe(false);
-    });
-    test('loadManyByQueryCursor should work', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Many Cursor' }));
-        const cursor = simpleItemRepo.loadManyByQueryCursor({ label: 'Many Cursor' });
-        const results = await toArrayAsync(cursor);
-        expect(results).toHaveLength(1);
-    });
-    test('upsert (non-CTI) with wheres', async () => {
-        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Upsert' }));
-        // This should succeed
-        const upserted = await simpleItemRepo.upsert(['label'], Object.assign(new SimpleItem(), { label: 'Upsert' }), { label: 'Upsert Updated' }, { set: { label: 'Upsert' } });
-        expect(upserted.label).toBe('Upsert Updated');
-        // This should fail to return a row due to condition
-        await expect(simpleItemRepo.upsert(['label'], Object.assign(new SimpleItem(), { label: 'Upsert Updated' }), { label: 'Should Not Happen' }, { set: { label: 'Wrong' } }))
-            .rejects.toThrow('upsert failed to return a row');
-    });
-    test('updateMany (non-CTI) with empty array', async () => {
-        expect(await simpleItemRepo.updateMany([], { label: 'None' })).toEqual([]);
-    });
-    test('hardDeleteByQuery throws NotFoundError', async () => {
-        await expect(simpleItemRepo.hardDeleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
-    });
-    test('hardDeleteMany with empty array', async () => {
-        expect(await simpleItemRepo.hardDeleteMany([])).toEqual([]);
-    });
-    test('convertOrderBy with various inputs', async () => {
-        expect(simpleItemRepo.convertOrderBy('label')).toBeDefined();
-        expect(simpleItemRepo.convertOrderBy(['label', ['id', 'desc']])).toHaveLength(2);
-        expect(simpleItemRepo.convertOrderBy(sql `label`)).toHaveLength(1);
-    });
-    test('mapManyToEntity and mapToEntity with subclasses', async () => {
-        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'P1', code: 'C1' }));
-        const polymorphic = await baseItemRepo.load(item.id, { includeSubclasses: true });
-        expect(polymorphic).toBeInstanceOf(PremiumItem);
-        // We need to manually construct the polymorphic row structure if we want to test mapManyToEntity directly with subclasses
-        // But loadAll({ includeSubclasses: true }) already does this.
-    });
-    test('tryUpdateCTI with no changes', async () => {
-        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'NoChange', code: 'NC' }));
-        const updated = await premiumItemRepo.tryUpdate(item.id, {});
-        expect(updated.id).toBe(item.id);
-    });
-    test('tsvector search with various options', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Search Item' }));
-        // score: false
-        const r1 = await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Search' } },
-            score: false,
-        });
-        expect(r1[0].score).toBeUndefined();
-        // highlight variants
-        const r2 = await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Search' } },
-            highlight: 'label',
-        });
-        expect(r2[0].highlight).toBeDefined();
-        const r3 = await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Search' } },
-            highlight: { source: sql `label`, minWords: 5, maxWords: 10 },
-        });
-        expect(r3[0].highlight).toBeDefined();
-        // offset and limit
-        const r4 = await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Search' } },
-            offset: 0,
-            limit: 1,
-        });
-        expect(r4).toHaveLength(1);
-    });
-    test('trigram search with rank: false', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Trigram' }));
-        const results = await simpleItemRepo.search({
-            query: { $trigram: { fields: ['label'], query: 'Trigram' } },
-            rank: false,
-        });
-        expect(results).toHaveLength(1);
-    });
-    test('PlainItem (no metadata) operations', async () => {
-        const item = await plainItemRepo.insert(Object.assign(new PlainItem(), { description: 'Plain' }));
-        expect(plainItemRepo.hasMetadata).toBe(false);
-        const deleted = await plainItemRepo.delete(item.id);
-        expect(deleted.description).toBe('Plain');
-        const exists = await plainItemRepo.has(item.id);
-        expect(exists).toBe(false);
-    });
-    test('convertOrderBy with object', async () => {
-        const order = simpleItemRepo.convertOrderBy({ label: 'desc' });
-        expect(order).toHaveLength(1);
-    });
-    test('tryHardDelete returning undefined', async () => {
-        const result = await simpleItemRepo.tryHardDelete('00000000-0000-0000-0000-000000000000');
-        expect(result).toBeUndefined();
-    });
-    test('tryHardDeleteByQuery returning undefined', async () => {
-        const result = await simpleItemRepo.tryHardDeleteByQuery({ label: 'Ghost' });
-        expect(result).toBeUndefined();
-    });
-    test('hardDeleteMany with empty array branch', async () => {
-        const results = await simpleItemRepo.hardDeleteMany([]);
-        expect(results).toEqual([]);
-    });
-    test('hardDeleteManyByQuery works', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'To Hard Delete' }));
-        const results = await simpleItemRepo.hardDeleteManyByQuery({ label: 'To Hard Delete' });
-        expect(results).toHaveLength(1);
-    });
-    test('applySelect with false (default)', async () => {
-        const q = simpleItemRepo.applySelect(database, undefined, false);
-        expect(q).toBeDefined();
-    });
-    test('load should throw NotFoundError', async () => {
-        await expect(simpleItemRepo.load('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
-    });
-    test('tsvector search with rank number', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Rank' }));
-        const results = await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Rank' } },
-            rank: { normalization: 1 }, // normalization
-        });
-        expect(results).toHaveLength(1);
-    });
-    test('encryptionSecret usage in getTransformContext', async () => {
-        const context = await simpleItemRepo.getTransformContext();
-        expect(context.encryptionKey).toBeDefined();
-        // Call it again to hit the cached branch
-        const context2 = await simpleItemRepo.getTransformContext();
-        expect(context2).toBe(context);
-    });
-    test('tsvector search with rank true/false', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Rank' }));
-        await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Rank' } },
-            rank: true,
-        });
-        await simpleItemRepo.search({
-            query: { $tsvector: { fields: ['label'], query: 'Rank' } },
-            rank: false,
-        });
-    });
-    test('trigram search with threshold', async () => {
-        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Trigram Threshold' }));
-        await database.execute(sql `SET pg_trgm.similarity_threshold = 0.1`);
-        const results = await simpleItemRepo.search({
-            query: { $trigram: { fields: ['label'], query: 'Trigram', threshold: 0.1 } },
-        });
-        expect(results).toHaveLength(1);
-    });
-    test('repository resolution inside transaction', async () => {
-        await simpleItemRepo.transaction(async (transaction) => {
-            const repository = injector.resolve(getRepository(SimpleItem)).withTransaction(transaction);
-            expect(repository).toBeDefined();
-        });
-    });
-    test('updateManyCTI with no matches', async () => {
-        const results = await premiumItemRepo.updateMany(['00000000-0000-0000-0000-000000000000'], { name: 'Ghost' });
-        expect(results).toEqual([]);
-    });
-    test('upsertMany on CTI with wheres and update object', async () => {
-        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'UpsertManyCTI', code: 'U1' }));
-        const conflictItem = Object.assign(new PremiumItem(), { id: item.id, name: 'UpsertManyCTI', code: 'U1' });
-        const results = await premiumItemRepo.upsertMany(['id'], [conflictItem], { name: 'UpsertManyCTI Updated', code: 'U2' }, { target: { name: 'UpsertManyCTI' } });
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe('UpsertManyCTI Updated');
-        expect(results[0].code).toBe('U2');
-    });
-    test('processExpirations with no expiration columns', async () => {
-        await simpleItemRepo.processExpirations(); // Should just return
-    });
-});

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

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

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

@@ -1,65 +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 { describe, expect, test } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/repository.js';
-describe('ORM Repository Mapping (CTI)', () => {
-    test('should flatten joined result when mapping child entity', async () => {
-        let BaseUser = class BaseUser extends Entity {
-            type;
-            name;
-        };
-        __decorate([
-            StringProperty(),
-            Column({ name: 'type' }),
-            __metadata("design:type", String)
-        ], BaseUser.prototype, "type", void 0);
-        __decorate([
-            StringProperty(),
-            Column({ name: 'name' }),
-            __metadata("design:type", String)
-        ], BaseUser.prototype, "name", void 0);
-        BaseUser = __decorate([
-            Table('users', { schema: 'test' }),
-            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-        ], BaseUser);
-        let Admin = class Admin extends BaseUser {
-            role;
-        };
-        __decorate([
-            StringProperty(),
-            Column({ name: 'role' }),
-            __metadata("design:type", String)
-        ], Admin.prototype, "role", void 0);
-        Admin = __decorate([
-            Table('admins', { schema: 'test' }),
-            ChildEntity('admin')
-        ], Admin);
-        const { injector } = await setupIntegrationTest({ orm: { schema: 'test' } });
-        const repository = injector.resolve(getRepository(Admin));
-        // Simulate Drizzle joined result structure
-        const mockResult = {
-            users: { id: '123', type: 'admin', name: 'John Doe', revision: 1 },
-            admins: { id: '123', type: 'admin', role: 'super-admin' },
-        };
-        // Access private method for testing (using any cast)
-        const mappedEntity = await repository._mapToEntity(mockResult, {});
-        expect(mappedEntity).toBeInstanceOf(Admin);
-        expect(mappedEntity.id).toBe('123');
-        expect(mappedEntity.type).toBe('admin');
-        expect(mappedEntity.name).toBe('John Doe');
-        expect(mappedEntity.role).toBe('super-admin');
-        expect(mappedEntity.metadata.revision).toBe(1);
-    });
-});

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

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