@tstdl/base 0.93.87 → 0.93.90

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

@@ -0,0 +1,456 @@
+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 { dropTables, setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { Database, injectRepository } from '../server/index.js';
+describe('ORM Repository CTI (Integration)', () => {
+    let injector;
+    let database;
+    const schema = 'test_orm_cti';
+    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 }),
+        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 }),
+        ChildEntity('admin')
+    ], Admin);
+    let Guest = class Guest extends BaseUser {
+        permissions;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'permissions' }),
+        __metadata("design:type", String)
+    ], Guest.prototype, "permissions", void 0);
+    Guest = __decorate([
+        Table('guests', { schema }),
+        ChildEntity('guest')
+    ], Guest);
+    let Staff = class Staff extends BaseUser {
+        employeeId;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'employee_id' }),
+        __metadata("design:type", String)
+    ], Staff.prototype, "employeeId", void 0);
+    Staff = __decorate([
+        Table('staff', { schema }),
+        Inheritance({ strategy: 'joined' }),
+        ChildEntity('staff')
+    ], Staff);
+    let Manager = class Manager extends Staff {
+        department;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'department' }),
+        __metadata("design:type", String)
+    ], Manager.prototype, "department", void 0);
+    Manager = __decorate([
+        Table('managers', { schema }),
+        ChildEntity('manager')
+    ], Manager);
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await dropTables(database, schema, ['managers', 'staff', 'guests', 'admins', 'users']);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('users')} (
+        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('admins')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'admin'),
+        role TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('users')} (id, type) ON DELETE CASCADE
+      )
+    `);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('guests')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'guest'),
+        permissions TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('users')} (id, type) ON DELETE CASCADE
+      )
+    `);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('staff')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL,
+        employee_id TEXT NOT NULL,
+        UNIQUE (id, type),
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('users')} (id, type) ON DELETE CASCADE
+      )
+    `);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('managers')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'manager'),
+        department TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('staff')} (id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should insert into both parent and child tables', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Admin);
+            const newAdmin = new Admin();
+            newAdmin.name = 'Alice';
+            newAdmin.role = 'SuperAdmin';
+            const inserted = await repository.insert(newAdmin);
+            expect(inserted).toBeInstanceOf(Admin);
+            expect(inserted.id).toBeDefined();
+            expect(inserted.name).toBe('Alice');
+            expect(inserted.role).toBe('SuperAdmin');
+            expect(inserted.type).toBe('admin');
+            expect(inserted.metadata.revision).toBe(1);
+            // Verify DB state
+            const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+            expect(userRow).toBeDefined();
+            expect(userRow.type).toBe('admin');
+            expect(userRow.name).toBe('Alice');
+            expect(userRow.revision).toBe(1);
+            const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+            expect(adminRow).toBeDefined();
+            expect(adminRow.type).toBe('admin');
+            expect(adminRow.role).toBe('SuperAdmin');
+        });
+    });
+    test('should insert many into both parent and child tables', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Admin);
+            const admins = [
+                Object.assign(new Admin(), { name: 'Bob', role: 'Admin' }),
+                Object.assign(new Admin(), { name: 'Charlie', role: 'Moderator' }),
+            ];
+            const insertedAdmins = await repository.insertMany(admins);
+            expect(insertedAdmins).toHaveLength(2);
+            expect(insertedAdmins[0].name).toBe('Bob');
+            expect(insertedAdmins[1].name).toBe('Charlie');
+            expect(insertedAdmins[0].type).toBe('admin');
+            expect(insertedAdmins[1].type).toBe('admin');
+            for (const inserted of insertedAdmins) {
+                const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+                expect(userRow.name).toBe(inserted.name);
+                const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+                expect(adminRow.role).toBe(inserted.role);
+            }
+        });
+    });
+    test('should update both parent and child tables', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Admin);
+            const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
+            const inserted = await repository.insert(newAdmin);
+            const update = { name: 'Alice Updated', role: 'MegaAdmin' };
+            const updated = await repository.update(inserted.id, update);
+            expect(updated.name).toBe('Alice Updated');
+            expect(updated.role).toBe('MegaAdmin');
+            expect(updated.metadata.revision).toBe(2);
+            // Verify DB state
+            const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+            expect(userRow.name).toBe('Alice Updated');
+            expect(userRow.revision).toBe(2);
+            const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+            expect(adminRow.role).toBe('MegaAdmin');
+        });
+    });
+    test('should soft delete from parent table', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Admin);
+            const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
+            const inserted = await repository.insert(newAdmin);
+            await repository.delete(inserted.id);
+            // Verify DB state
+            const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+            expect(userRow.delete_timestamp).not.toBeNull();
+            // Child table should still have the row (soft delete only affects parent)
+            const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+            expect(adminRow).toBeDefined();
+        });
+    });
+    test('should hard delete from both tables via cascade', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Admin);
+            const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
+            const inserted = await repository.insert(newAdmin);
+            await repository.hardDelete(inserted.id);
+            // Verify DB state
+            const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+            expect(userRows).toHaveLength(0);
+            const { rows: adminRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+            expect(adminRows).toHaveLength(0);
+        });
+    });
+    test('should load entities polymorphically from parent repository', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const guestRepository = injectRepository(Guest);
+            const userRepository = injectRepository(BaseUser);
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
+            await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
+            // Load without subclasses (default)
+            const users = await userRepository.loadAll();
+            expect(users).toHaveLength(2);
+            expect(users[0]).toBeInstanceOf(BaseUser);
+            expect(users[1]).toBeInstanceOf(BaseUser);
+            expect(users[0].role).toBeUndefined();
+            // Load with subclasses
+            const polymorphicUsers = await userRepository.loadAll({ includeSubclasses: true });
+            expect(polymorphicUsers).toHaveLength(2);
+            const admin = polymorphicUsers.find((u) => u instanceof Admin);
+            const guest = polymorphicUsers.find((u) => u instanceof Guest);
+            expect(admin).toBeDefined();
+            expect(admin).toBeInstanceOf(Admin);
+            expect(admin.name).toBe('Admin1');
+            expect(admin.role).toBe('Super');
+            expect(guest).toBeDefined();
+            expect(guest).toBeInstanceOf(Guest);
+            expect(guest.name).toBe('Guest1');
+            expect(guest).toBeInstanceOf(Guest);
+            expect(guest.name).toBe('Guest1');
+            expect(guest.permissions).toBe('Read');
+        });
+    });
+    test('should load polymorphic subset from parent repository', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const guestRepository = injectRepository(Guest);
+            const userRepository = injectRepository(BaseUser);
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
+            await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
+            // Load ONLY Admins polymorphically
+            const onlyAdmins = await userRepository.loadManyByQuery({}, { includeSubclasses: [Admin] });
+            expect(onlyAdmins).toHaveLength(2); // Still returns all users from base table
+            const admin = onlyAdmins.find((u) => u instanceof Admin);
+            const guestAsBase = onlyAdmins.find((u) => u.name === 'Guest1');
+            expect(admin).toBeInstanceOf(Admin);
+            expect(admin.role).toBe('Super');
+            expect(guestAsBase).not.toBeInstanceOf(Guest);
+            expect(guestAsBase).toBeInstanceOf(BaseUser);
+        });
+    });
+    test('should count and check existence for child entities', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const guestRepository = injectRepository(Guest);
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin2', role: 'Normal' }));
+            await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
+            expect(await adminRepository.count()).toBe(2);
+            expect(await guestRepository.count()).toBe(1);
+            const admins = await adminRepository.loadAll();
+            expect(await adminRepository.has(admins[0].id)).toBe(true);
+            expect(await adminRepository.hasByQuery({ name: 'Admin2' })).toBe(true);
+            expect(await adminRepository.hasByQuery({ name: 'Guest1' })).toBe(false); // Different table
+        });
+    });
+    test('should query child entities by parent fields', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'TargetAdmin', role: 'Super' }));
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'OtherAdmin', role: 'Normal' }));
+            const results = await adminRepository.loadManyByQuery({ name: 'TargetAdmin' });
+            expect(results).toHaveLength(1);
+            expect(results[0].name).toBe('TargetAdmin');
+            expect(results[0].role).toBe('Super');
+        });
+    });
+    test('should perform partial updates on parent or child fields', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const inserted = await adminRepository.insert(Object.assign(new Admin(), { name: 'Alice', role: 'Super' }));
+            // Update only parent field
+            await adminRepository.update(inserted.id, { name: 'Alice Renamed' });
+            let updated = await adminRepository.load(inserted.id);
+            expect(updated.name).toBe('Alice Renamed');
+            expect(updated.role).toBe('Super');
+            // Update only child field
+            await adminRepository.update(inserted.id, { role: 'Demoted' });
+            updated = await adminRepository.load(inserted.id);
+            expect(updated.name).toBe('Alice Renamed');
+            expect(updated.role).toBe('Demoted');
+        });
+    });
+    test('should fail when violating discriminator check constraint', async () => {
+        // Attempt manual insert with mismatched type
+        const query = database.execute(sql `
+      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('admins')} (id, type, role)
+      VALUES (gen_random_uuid(), 'guest', 'Invalid')
+    `);
+        await expect(query).rejects.toThrow();
+    });
+    test('should fail when violating composite foreign key', async () => {
+        // Insert user with type 'guest'
+        const userId = '00000000-0000-0000-0000-000000000001';
+        await database.execute(sql `
+      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('users')} (id, type, name, revision, revision_timestamp, create_timestamp)
+      VALUES (${userId}, 'guest', 'Guest User', 1, now(), now())
+    `);
+        // Attempt to insert admin pointing to that user (mismatched type 'admin' vs 'guest')
+        const query = database.execute(sql `
+      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('admins')} (id, type, role)
+      VALUES (${userId}, 'admin', 'Admin Role')
+    `);
+        await expect(query).rejects.toThrow();
+    });
+    test('should support nested inheritance', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const managerRepository = injectRepository(Manager);
+            const manager = new Manager();
+            manager.name = 'Big Boss';
+            manager.employeeId = 'EMP001';
+            manager.department = 'Executive';
+            const inserted = await managerRepository.insert(manager);
+            expect(inserted.name).toBe('Big Boss');
+            expect(inserted.employeeId).toBe('EMP001');
+            expect(inserted.department).toBe('Executive');
+            expect(inserted.type).toBe('manager');
+            // Verify DB state - all 3 tables should have rows
+            const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+            expect(userRow.name).toBe('Big Boss');
+            const { rows: [staffRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
+            expect(staffRow.employee_id).toBe('EMP001');
+            const { rows: [managerRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
+            expect(managerRow.department).toBe('Executive');
+        });
+    });
+    test('should rollback parent insert if child insert fails', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            // Attempt to insert an admin with a missing role (should fail because of NOT NULL)
+            const invalidAdmin = new Admin();
+            invalidAdmin.name = 'Broken Admin';
+            // role is missing
+            await expect(adminRepository.insert(invalidAdmin)).rejects.toThrow();
+            // Verify that NO row was created in the users table
+            const { rows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')}`);
+            expect(rows).toHaveLength(0);
+        });
+    });
+    test('should count and check existence polymorphically', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const guestRepository = injectRepository(Guest);
+            const userRepository = injectRepository(BaseUser);
+            await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
+            await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
+            expect(await userRepository.count()).toBe(2);
+            expect(await userRepository.hasByQuery({ name: 'A1' })).toBe(true);
+            expect(await userRepository.hasByQuery({ name: 'G1' })).toBe(true);
+        });
+    });
+    test('should load many by IDs polymorphically', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const guestRepository = injectRepository(Guest);
+            const userRepository = injectRepository(BaseUser);
+            const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
+            const g1 = await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
+            const results = await userRepository.loadMany([a1.id, g1.id], { includeSubclasses: true });
+            expect(results).toHaveLength(2);
+            expect(results.find((u) => u.id === a1.id)).toBeInstanceOf(Admin);
+            expect(results.find((u) => u.id === g1.id)).toBeInstanceOf(Guest);
+        });
+    });
+    test('should update many child entities', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const adminRepository = injectRepository(Admin);
+            const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'Old' }));
+            const a2 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A2', role: 'Old' }));
+            await adminRepository.updateMany([a1.id, a2.id], { role: 'New' });
+            const results = await adminRepository.loadMany([a1.id, a2.id]);
+            expect(results[0].role).toBe('New');
+            expect(results[1].role).toBe('New');
+        });
+    });
+    test('should update nested inheritance fields', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const managerRepository = injectRepository(Manager);
+            const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
+            const inserted = await managerRepository.insert(manager);
+            await managerRepository.update(inserted.id, { name: 'New Boss', employeeId: 'E2', department: 'D2' });
+            const updated = await managerRepository.load(inserted.id);
+            expect(updated.name).toBe('New Boss');
+            expect(updated.employeeId).toBe('E2');
+            expect(updated.department).toBe('D2');
+        });
+    });
+    test('should delete from nested inheritance tables', async () => {
+        await truncateTables(database, schema, ['users']);
+        await runInInjectionContext(injector, async () => {
+            const managerRepository = injectRepository(Manager);
+            const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
+            const inserted = await managerRepository.insert(manager);
+            await managerRepository.hardDelete(inserted.id);
+            const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+            const { rows: staffRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
+            const { rows: managerRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
+            expect(userRows).toHaveLength(0);
+            expect(staffRows).toHaveLength(0);
+            expect(managerRows).toHaveLength(0);
+        });
+    });
+});

package/orm/tests/repository-edge-cases.test.d.ts

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