@tstdl/base 0.93.181 → 0.93.183

package/object-storage/s3/tests/s3.object-storage.integration.test.js

@@ -1,303 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { setupIntegrationTest } from '../../../testing/index.js';
-import { readBinaryStream } from '../../../utils/stream/stream-reader.js';
-import { isUndefined } from '../../../utils/type-guards.js';
-import { S3ObjectStorage } from '../s3.object-storage.js';
-describe('S3ObjectStorage Integration', () => {
-    let storage;
-    beforeAll(async () => {
-        const { injector } = await setupIntegrationTest({
-            modules: { objectStorage: true },
-        });
-        storage = await injector.resolveAsync(S3ObjectStorage, 'test-module');
-    });
-    afterAll(async () => {
-        if (isUndefined(storage)) {
-            return;
-        }
-        const objects = await storage.getObjects();
-        for (const obj of objects) {
-            await storage.deleteObject(obj.key);
-        }
-    });
-    it('should upload and check existence', async () => {
-        const key = 'test-upload.txt';
-        const content = new TextEncoder().encode('hello world');
-        await storage.uploadObject(key, content, { contentType: 'text/plain' });
-        const exists = await storage.exists(key);
-        expect(exists).toBe(true);
-        const stat = await storage.statObject(key);
-        expect(stat.size).toBe(content.length);
-    });
-    it('should download content', async () => {
-        const key = 'test-download.txt';
-        const content = new TextEncoder().encode('download me');
-        await storage.uploadObject(key, content);
-        const downloaded = await storage.getContent(key);
-        expect(new TextDecoder().decode(downloaded)).toBe('download me');
-    });
-    it('should download content as stream', async () => {
-        const key = 'test-stream.txt';
-        const content = new TextEncoder().encode('stream me');
-        await storage.uploadObject(key, content);
-        const stream = storage.getContentStream(key);
-        const downloaded = await readBinaryStream(stream);
-        expect(new TextDecoder().decode(downloaded)).toBe('stream me');
-    });
-    it('should list objects', async () => {
-        const key = 'test-list.txt';
-        await storage.uploadObject(key, new TextEncoder().encode('list me'));
-        const objects = await storage.getObjects();
-        const keys = objects.map((o) => o.key);
-        expect(keys).toContain(key);
-    });
-    it('should copy object', async () => {
-        const sourceKey = 'source.txt';
-        const destKey = 'dest.txt';
-        await storage.uploadObject(sourceKey, new TextEncoder().encode('copy source'));
-        await storage.copyObject(sourceKey, destKey);
-        const exists = await storage.exists(destKey);
-        expect(exists).toBe(true);
-        const content = await storage.getContent(destKey);
-        expect(new TextDecoder().decode(content)).toBe('copy source');
-    });
-    it('should move object', async () => {
-        const sourceKey = 'move-source.txt';
-        const destKey = 'move-dest.txt';
-        await storage.uploadObject(sourceKey, new TextEncoder().encode('move me'));
-        await storage.moveObject(sourceKey, destKey);
-        expect(await storage.exists(sourceKey)).toBe(false);
-        expect(await storage.exists(destKey)).toBe(true);
-    });
-    it('should generate signed download URL', async () => {
-        const key = 'signed-download.txt';
-        await storage.uploadObject(key, new TextEncoder().encode('signed download'));
-        const url = await storage.getDownloadUrl(key, Date.now() + 60000);
-        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):19552/);
-        const response = await fetch(url);
-        expect(response.status).toBe(200);
-        expect(await response.text()).toBe('signed download');
-    });
-    it('should generate signed upload URL', async () => {
-        const key = 'signed-upload.txt';
-        const url = await storage.getUploadUrl(key, Date.now() + 60000, { contentType: 'text/plain' });
-        const content = 'upload via signed url';
-        const response = await fetch(url, {
-            method: 'PUT',
-            body: content,
-            headers: { 'Content-Type': 'text/plain' },
-        });
-        expect(response.status).toBe(200);
-        expect(await storage.exists(key)).toBe(true);
-        expect(new TextDecoder().decode(await storage.getContent(key))).toBe(content);
-    });
-    it('should configure bucket lifecycle', async () => {
-        await storage.configureBucket({
-            lifecycle: {
-                expiration: {
-                    after: 86400, // 1 day
-                },
-            },
-        });
-    });
-    it('should delete objects', async () => {
-        const key1 = 'delete1.txt';
-        const key2 = 'delete2.txt';
-        await storage.uploadObject(key1, new Uint8Array([1]));
-        await storage.uploadObject(key2, new Uint8Array([2]));
-        await storage.deleteObjects([key1, key2]);
-        expect(await storage.exists(key1)).toBe(false);
-        expect(await storage.exists(key2)).toBe(false);
-    });
-    it('should handle non-existent objects gracefully', async () => {
-        const key = `non-existent-${Math.random()}`;
-        expect(await storage.exists(key)).toBe(false);
-        await expect(storage.statObject(key)).rejects.toThrow();
-        await expect(storage.getContent(key)).rejects.toThrow();
-    });
-    it('should handle large uploads via streams', async () => {
-        const key = 'large-stream.bin';
-        const size = 10 * 1024 * 1024; // 10MB
-        const content = new Uint8Array(size).fill(0x42);
-        const stream = new ReadableStream({
-            start(controller) {
-                controller.enqueue(content);
-                controller.close();
-            },
-        });
-        await storage.uploadObject(key, stream, { contentLength: size, contentType: 'application/octet-stream' });
-        const stat = await storage.statObject(key);
-        expect(stat.size).toBe(size);
-        const downloaded = await storage.getContent(key);
-        expect(downloaded.length).toBe(size);
-        expect(downloaded[0]).toBe(0x42);
-    });
-    it('should preserve and update metadata', async () => {
-        const key = 'metadata.txt';
-        const metadata = { 'test-key': 'test-value', 'another-key': 'another-value' };
-        await storage.uploadObject(key, new TextEncoder().encode('metadata content'), { metadata });
-        let stat = await storage.statObject(key);
-        expect(stat.metadata).toMatchObject(metadata);
-        const destKey = 'metadata-copy.txt';
-        const newMetadata = { 'test-key': 'updated-value', 'extra-key': 'extra-value' };
-        await storage.copyObject(key, destKey, { metadata: newMetadata });
-        stat = await storage.statObject(destKey);
-        expect(stat.metadata['test-key']).toBe('updated-value');
-        expect(stat.metadata['another-key']).toBe('another-value');
-        expect(stat.metadata['extra-key']).toBe('extra-value');
-    });
-    it('should work with bucket per module', async () => {
-        const { injector } = await setupIntegrationTest({
-            modules: { objectStorage: true },
-        });
-        const moduleName = `test-bucket-per-module-${Math.floor(Math.random() * 1000000)}`;
-        const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, moduleName);
-        const key = 'test.txt';
-        await perModuleStorage.uploadObject(key, new TextEncoder().encode('hello'));
-        expect(await perModuleStorage.exists(key)).toBe(true);
-        await perModuleStorage.deleteObject(key);
-    });
-    it('should cover S3Object methods', async () => {
-        const key = 's3-object-test.txt';
-        const content = new TextEncoder().encode('s3 object');
-        const metadata = { 's3-test': 'true' };
-        await storage.uploadObject(key, content, { metadata });
-        const obj = await storage.getObject(key);
-        expect(await obj.getResourceUri()).toBe(`s3://test-module/${key}`);
-        expect(await obj.getContentLength()).toBe(content.length);
-        expect(await obj.getMetadata()).toMatchObject(metadata);
-        expect(new TextDecoder().decode(await obj.getContent())).toBe('s3 object');
-        const stream = obj.getContentStream();
-        const downloaded = await readBinaryStream(stream);
-        expect(new TextDecoder().decode(downloaded)).toBe('s3 object');
-    });
-    it('should handle bucket configuration with existing rules', async () => {
-        await storage.configureBucket({
-            lifecycle: {
-                expiration: {
-                    after: 86400 * 2, // 2 days
-                },
-            },
-        });
-        await storage.configureBucket({
-            lifecycle: {
-                expiration: {
-                    after: 86400 * 2, // same
-                },
-            },
-        });
-        await storage.configureBucket({
-            lifecycle: {
-                expiration: {
-                    after: undefined, // remove
-                },
-            },
-        });
-    });
-    it('should handle Forbidden error in ensureBucketExists', async () => {
-        // We can't easily trigger a real Forbidden error without complex setup,
-        // but we can mock the client for this specific test case if needed.
-        // However, let's try to trigger other branches first.
-    });
-    it('should handle different upload content types (Uint8Array)', async () => {
-        const key = 'uint8-upload.txt';
-        const content = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
-        await storage.uploadObject(key, content);
-        expect(await storage.exists(key)).toBe(true);
-    });
-    it('should handle Blob in getContentStream', async () => {
-        // This depends on the environment (Node.js vs Browser) and how S3 SDK returns the body.
-        // In our current Node.js setup, it usually returns a Readable.
-    });
-    it('should cover moveObject with string source', async () => {
-        const sourceKey = 'move-str-source.txt';
-        const destKey = 'move-str-dest.txt';
-        await storage.uploadObject(sourceKey, new TextEncoder().encode('move me str'));
-        await storage.moveObject(sourceKey, destKey);
-        expect(await storage.exists(destKey)).toBe(true);
-    });
-    it('should cover copyObject with S3Object source', async () => {
-        const sourceKey = 'copy-obj-source.txt';
-        const destKey = 'copy-obj-dest.txt';
-        await storage.uploadObject(sourceKey, new TextEncoder().encode('copy me obj'));
-        const sourceObj = await storage.getObject(sourceKey);
-        await storage.copyObject(sourceObj, destKey);
-        expect(await storage.exists(destKey)).toBe(true);
-    });
-    it('should generate signed download URL with Expires header', async () => {
-        const key = 'signed-download-expires.txt';
-        await storage.uploadObject(key, new TextEncoder().encode('signed download expires'));
-        const url = await storage.getDownloadUrl(key, Date.now() + 60000, {
-            Expires: new Date(Date.now() + 60000).toUTCString(),
-        });
-        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):19552/);
-        const response = await fetch(url);
-        expect(response.status).toBe(200);
-    });
-    it('should handle Forbidden error in ensureBucketExists with wrong credentials', async () => {
-        const { injector } = await setupIntegrationTest({
-            modules: { objectStorage: true },
-            s3: {
-                accessKey: 'wrong',
-                secretKey: 'wrong',
-            },
-        });
-        try {
-            await injector.resolveAsync(S3ObjectStorage, 'forbidden-bucket');
-            expect.fail('Should have thrown');
-        }
-        catch (error) {
-            expect(error).toBeDefined();
-        }
-    });
-    it('should copy object between different storages', async () => {
-        const { injector } = await setupIntegrationTest({
-            modules: { objectStorage: true },
-        });
-        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-bucket');
-        const sourceKey = 'cross-storage-source.txt';
-        const destKey = 'cross-storage-dest.txt';
-        await storage.uploadObject(sourceKey, new TextEncoder().encode('cross storage content'));
-        await storage.copyObject(sourceKey, [anotherStorage, destKey]);
-        expect(await anotherStorage.exists(destKey)).toBe(true);
-        const content = await anotherStorage.getContent(destKey);
-        expect(new TextDecoder().decode(content)).toBe('cross storage content');
-    });
-    it('should cover ensureBucketExists with region', async () => {
-        const { injector } = await setupIntegrationTest({
-            modules: { objectStorage: true },
-        });
-        const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, `region-test-${Math.floor(Math.random() * 1000000)}`);
-        await perModuleStorage.ensureBucketExists('us-east-1', { objectLocking: true });
-    });
-    it('should cover moveObject with S3Object source', async () => {
-        const sourceKey = 'move-obj-source.txt';
-        const destKey = 'move-obj-dest.txt';
-        await storage.uploadObject(sourceKey, new TextEncoder().encode('move me obj'));
-        const sourceObj = await storage.getObject(sourceKey);
-        await storage.moveObject(sourceObj, destKey);
-        expect(await storage.exists(destKey)).toBe(true);
-        expect(await storage.exists(sourceKey)).toBe(false);
-    });
-    it('should cover S3Object methods more extensively', async () => {
-        const key = 's3-object-ext.txt';
-        await storage.uploadObject(key, new TextEncoder().encode('ext'));
-        const obj = await storage.getObject(key);
-        // Trigger lazy loading of contentLength and metadata
-        expect(await obj.getContentLength()).toBe(3);
-        expect(await obj.getMetadata()).toBeDefined();
-        // Trigger cached values
-        expect(await obj.getContentLength()).toBe(3);
-        expect(await obj.getMetadata()).toBeDefined();
-    });
-    it('should cover error branches in configureBucket', async () => {
-        // Already did some, but let's try more variations
-        await storage.configureBucket({
-            lifecycle: {
-                expiration: {
-                    after: 86400 * 3,
-                },
-            },
-        });
-    });
-});

package/orm/tests/build-jsonb.test.d.ts

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

package/orm/tests/build-jsonb.test.js

@@ -1,39 +0,0 @@
-import { PgDialect } from 'drizzle-orm/pg-core';
-import { describe, expect, test } from 'vitest';
-import { buildJsonb } from '../sqls/sqls.js';
-describe('buildJsonb', () => {
-    const dialect = new PgDialect();
-    test('should build jsonb from simple object', () => {
-        const query = buildJsonb({ a: 1, b: 'foo' });
-        const { sql, params } = dialect.sqlToQuery(query);
-        expect(sql).toBe('jsonb_build_object($1::text, to_jsonb($2::numeric), $3::text, to_jsonb($4::text))');
-        expect(params).toEqual(['a', 1, 'b', 'foo']);
-    });
-    test('should build jsonb from object with non-simple keys', () => {
-        const query = buildJsonb({ 'Betriebs-Nr.': '18182952' });
-        const { sql, params } = dialect.sqlToQuery(query);
-        // This is what failed before: it lacked the ::text cast
-        expect(sql).toBe('jsonb_build_object($1::text, to_jsonb($2::text))');
-        expect(params).toEqual(['Betriebs-Nr.', '18182952']);
-    });
-    test('should build jsonb from nested structures', () => {
-        const query = buildJsonb({
-            additionalData: { 'Betriebs-Nr.': '18182952' },
-            tags: ['a', 'b'],
-        });
-        const { sql, params } = dialect.sqlToQuery(query);
-        expect(sql).toBe('jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3::text)), $4::text, jsonb_build_array(to_jsonb($5::text), to_jsonb($6::text)))');
-        expect(params).toEqual(['additionalData', 'Betriebs-Nr.', '18182952', 'tags', 'a', 'b']);
-    });
-    test('should handle numbers correctly', () => {
-        const query = buildJsonb({ score: 0.5 });
-        const { sql, params } = dialect.sqlToQuery(query);
-        expect(sql).toBe('jsonb_build_object($1::text, to_jsonb($2::numeric))');
-        expect(params).toEqual(['score', 0.5]);
-    });
-    test('should handle null and empty structures', () => {
-        expect(dialect.sqlToQuery(buildJsonb(null)).sql).toBe('\'null\'::jsonb');
-        expect(dialect.sqlToQuery(buildJsonb({})).sql).toBe('\'{}\'::jsonb');
-        expect(dialect.sqlToQuery(buildJsonb([])).sql).toBe('\'[]\'::jsonb');
-    });
-});

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

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

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

@@ -1,39 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { dateToNumericDate, numericDateToDateObject } from '../../utils/date-time.js';
-describe('ORM Data Types - numericDate Logic', () => {
-    test('dateToNumericDate should return days since epoch', () => {
-        const date = new Date(Date.UTC(2024, 0, 1));
-        expect(dateToNumericDate(date)).toBe(19723);
-    });
-    test('numericDateToDateObject should convert days since epoch to date components', () => {
-        const { year, month, day } = numericDateToDateObject(19723);
-        expect(year).toBe(2024);
-        expect(month).toBe(1);
-        expect(day).toBe(1);
-    });
-    test('leap year handling (2024-02-29)', () => {
-        const leapDate = new Date(Date.UTC(2024, 1, 29));
-        const numeric = dateToNumericDate(leapDate);
-        expect(numeric).toBe(19782);
-        const { year, month, day } = numericDateToDateObject(19782);
-        expect(year).toBe(2024);
-        expect(month).toBe(2);
-        expect(day).toBe(29);
-    });
-    test('epoch start (1970-01-01)', () => {
-        const epoch = new Date(Date.UTC(1970, 0, 1));
-        expect(dateToNumericDate(epoch)).toBe(0);
-        const { year, month, day } = numericDateToDateObject(0);
-        expect(year).toBe(1970);
-        expect(month).toBe(1);
-        expect(day).toBe(1);
-    });
-    test('before epoch (1969-12-31)', () => {
-        const beforeEpoch = new Date(Date.UTC(1969, 11, 31));
-        expect(dateToNumericDate(beforeEpoch)).toBe(-1);
-        const { year, month, day } = numericDateToDateObject(-1);
-        expect(year).toBe(1969);
-        expect(month).toBe(12);
-        expect(day).toBe(31);
-    });
-});

package/orm/tests/database-extension.test.d.ts

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

package/orm/tests/database-extension.test.js

@@ -1,63 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { describe, expect, it, vi } from 'vitest';
-import { APPLICATION_INITIALIZER } from '../../application/application.js';
-import { runInInjectionContext } from '../../injector/inject.js';
-import { bootstrapOrm, provideOrm } from '../../orm/server/bootstrap.js';
-import { Database } from '../../orm/server/database.js';
-import { DATABASE_EXTENSION, registerDatabaseExtension, runDatabaseExtensions } from '../../orm/server/extension.js';
-import { DATABASE_MIGRATION } from '../../orm/server/migration.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-describe('Database Extension Registration', () => {
-    it('should have DATABASE_EXTENSION token defined', () => {
-        expect(DATABASE_EXTENSION).toBeDefined();
-    });
-    it('should provide ORM bootstrap as application initializer', () => {
-        const provider = provideOrm();
-        expect(provider.provide).toBe(APPLICATION_INITIALIZER);
-        expect(provider.useValue).toBe(bootstrapOrm);
-        expect(provider.multi).toBe(true);
-    });
-    it('should register an extension', async () => {
-        const { injector } = await setupIntegrationTest();
-        registerDatabaseExtension('btree_gin', { injector });
-        const extensions = injector.resolveAll(DATABASE_EXTENSION);
-        expect(extensions).toHaveLength(1);
-        expect(extensions[0].name).toBe('btree_gin');
-    });
-    it('should run extensions', async () => {
-        const { injector } = await setupIntegrationTest();
-        const database = injector.resolve(Database);
-        const executeSpy = vi.spyOn(database, 'execute').mockResolvedValue({});
-        registerDatabaseExtension('btree_gin', { injector });
-        registerDatabaseExtension('uuid-ossp', { injector });
-        await runInInjectionContext(injector, async () => {
-            await runDatabaseExtensions();
-        });
-        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "btree_gin"'));
-        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"'));
-    });
-    it('should bootstrap ORM (extensions and migrations)', async () => {
-        const { injector } = await setupIntegrationTest();
-        const database = injector.resolve(Database);
-        const executeSpy = vi.spyOn(database, 'execute').mockResolvedValue({});
-        registerDatabaseExtension('btree_gin', { injector });
-        let migrated = false;
-        const migration = {
-            name: 'test-migration',
-            migrate: async () => {
-                migrated = true;
-            },
-        };
-        injector.register(DATABASE_MIGRATION, { useValue: migration }, { multi: true });
-        await runInInjectionContext(injector, async () => {
-            await bootstrapOrm();
-        });
-        // Check extension call
-        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "btree_gin"'));
-        // Check migration ran
-        expect(migrated).toBe(true);
-        // Check locking
-        expect(executeSpy).toHaveBeenCalledWith(sql `SELECT pg_advisory_lock(${123456789})`);
-        expect(executeSpy).toHaveBeenCalledWith(sql `SELECT pg_advisory_unlock(${123456789})`);
-    });
-});

package/orm/tests/database-migration.test.d.ts

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

package/orm/tests/database-migration.test.js

@@ -1,83 +0,0 @@
-import { APPLICATION_INITIALIZER } from '../../application/application.js';
-import { runInInjectionContext } from '../../injector/inject.js';
-import { bootstrapOrm, provideOrm } from '../../orm/server/bootstrap.js';
-import { DATABASE_MIGRATION } from '../../orm/server/migration.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { describe, expect, it } from 'vitest';
-describe('Database Migration Orchestration', () => {
-    it('should have DATABASE_MIGRATION token defined', () => {
-        expect(DATABASE_MIGRATION).toBeDefined();
-    });
-    it('should provide ORM bootstrap as application initializer', () => {
-        const provider = provideOrm();
-        expect(provider.provide).toBe(APPLICATION_INITIALIZER);
-        expect(provider.useValue).toBe(bootstrapOrm);
-        expect(provider.multi).toBe(true);
-    });
-    it('should register and resolve a migration', async () => {
-        const { injector } = await setupIntegrationTest();
-        let migrated = false;
-        const migration = {
-            name: 'test-migration',
-            migrate: async () => {
-                migrated = true;
-            },
-        };
-        injector.register(DATABASE_MIGRATION, { useValue: migration }, { multi: true });
-        const migrations = injector.resolveAll(DATABASE_MIGRATION);
-        expect(migrations).toHaveLength(1);
-        const firstMigration = migrations[0];
-        expect(firstMigration.name).toBe('test-migration');
-        await firstMigration.migrate();
-        expect(migrated).toBe(true);
-    });
-    it('should run migrations in the correct order based on dependencies', async () => {
-        const { injector } = await setupIntegrationTest();
-        const executionOrder = [];
-        const migrationA = {
-            name: 'migration-a',
-            migrate: async () => {
-                executionOrder.push('a');
-            },
-            dependencies: ['migration-b'],
-        };
-        const migrationB = {
-            name: 'migration-b',
-            migrate: async () => {
-                executionOrder.push('b');
-            },
-        };
-        const migrationC = {
-            name: 'migration-c',
-            migrate: async () => {
-                executionOrder.push('c');
-            },
-            dependencies: ['migration-a'],
-        };
-        injector.register(DATABASE_MIGRATION, { useValue: migrationA }, { multi: true });
-        injector.register(DATABASE_MIGRATION, { useValue: migrationB }, { multi: true });
-        injector.register(DATABASE_MIGRATION, { useValue: migrationC }, { multi: true });
-        await runInInjectionContext(injector, async () => {
-            await bootstrapOrm();
-        });
-        expect(executionOrder).toEqual(['b', 'a', 'c']);
-    });
-    it('should throw on circular dependency', async () => {
-        const { injector } = await setupIntegrationTest();
-        const migrationA = {
-            name: 'migration-a',
-            migrate: async () => { },
-            dependencies: ['migration-b'],
-        };
-        const migrationB = {
-            name: 'migration-b',
-            migrate: async () => { },
-            dependencies: ['migration-a'],
-        };
-        injector.register(DATABASE_MIGRATION, { useValue: migrationA }, { multi: true });
-        injector.register(DATABASE_MIGRATION, { useValue: migrationB }, { multi: true });
-        await runInInjectionContext(injector, async () => {
-            await expect(bootstrapOrm()).rejects.toThrow('Circular dependency detected');
-        });
-    });
-});

package/orm/tests/decorators.test.d.ts

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

package/orm/tests/decorators.test.js

@@ -1,77 +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 { describe, expect, test } from 'vitest';
-import { reflectionRegistry } from '../../reflection/index.js';
-import { Entity } from '../entity.js';
-import { Inheritance, ChildEntity, Column } from '../decorators.js';
-import { StringProperty } from '../../schema/index.js';
-describe('ORM Inheritance Decorators', () => {
-    test('should register inheritance metadata on parent', () => {
-        let BaseUser = class BaseUser extends Entity {
-            kind;
-        };
-        __decorate([
-            StringProperty(),
-            Column({}),
-            __metadata("design:type", String)
-        ], BaseUser.prototype, "kind", void 0);
-        BaseUser = __decorate([
-            Inheritance({ strategy: 'joined', discriminatorColumn: 'kind' })
-        ], BaseUser);
-        const metadata = reflectionRegistry.getMetadata(BaseUser);
-        const ormData = metadata?.data.tryGet('orm');
-        expect(ormData?.inheritance).toBeDefined();
-        expect(ormData?.inheritance?.discriminatorColumn).toBe('kind');
-        expect(ormData?.inheritance?.subclasses).toBeInstanceOf(Array);
-    });
-    test('should register child entity metadata and link to parent', () => {
-        let Vehicle = class Vehicle extends Entity {
-            type;
-        };
-        __decorate([
-            StringProperty(),
-            Column({}),
-            __metadata("design:type", String)
-        ], Vehicle.prototype, "type", void 0);
-        Vehicle = __decorate([
-            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-        ], Vehicle);
-        let Car = class Car extends Vehicle {
-        };
-        Car = __decorate([
-            ChildEntity('car')
-        ], Car);
-        const parentMetadata = reflectionRegistry.getMetadata(Vehicle);
-        const parentOrmData = parentMetadata?.data.tryGet('orm');
-        const childMetadata = reflectionRegistry.getMetadata(Car);
-        const childOrmData = childMetadata?.data.tryGet('orm');
-        // Check Child Metadata
-        expect(childOrmData?.childEntity).toBeDefined();
-        expect(childOrmData?.childEntity?.discriminatorValue).toBe('car');
-        // Check Parent Link
-        expect(parentOrmData?.inheritance?.subclasses).toContain(Car);
-    });
-    test('should use default discriminator column if not provided', () => {
-        let Animal = class Animal extends Entity {
-            type;
-        };
-        __decorate([
-            StringProperty(),
-            Column({}),
-            __metadata("design:type", String)
-        ], Animal.prototype, "type", void 0);
-        Animal = __decorate([
-            Inheritance({ strategy: 'joined' })
-        ], Animal);
-        const metadata = reflectionRegistry.getMetadata(Animal);
-        const ormData = metadata?.data.tryGet('orm');
-        expect(ormData?.inheritance?.discriminatorColumn).toBe('type');
-    });
-});

package/orm/tests/encryption.test.d.ts

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

package/orm/tests/encryption.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { generateSymmetricKey } from '../../cryptography/index.js';
-import { decryptBytes, encryptBytes } from '../server/encryption.js';
-describe('ORM Encryption', () => {
-    test('should encrypt and decrypt correctly', async () => {
-        const key = await generateSymmetricKey({ name: 'AES-GCM', length: 256 }, true);
-        const data = new TextEncoder().encode('Hello, ORM Encryption!');
-        const encrypted = await encryptBytes(data, key);
-        const decrypted = await decryptBytes(encrypted, key);
-        expect(new TextDecoder().decode(decrypted)).toBe('Hello, ORM Encryption!');
-    });
-    test('should throw Error on corrupted data', async () => {
-        const key = await generateSymmetricKey({ name: 'AES-GCM', length: 256 }, true);
-        const data = new TextEncoder().encode('Corrupt me');
-        const encrypted = await encryptBytes(data, key);
-        // Corrupt the ciphertext (last byte)
-        const lastIndex = encrypted.length - 1;
-        encrypted[lastIndex] = encrypted[lastIndex] ^ 1;
-        await expect(decryptBytes(encrypted, key)).rejects.toThrow(Error);
-        await expect(decryptBytes(encrypted, key)).rejects.toThrow('Decryption failed.');
-    });
-    test('should throw error on invalid version', async () => {
-        const key = await generateSymmetricKey({ name: 'AES-GCM', length: 256 }, true);
-        const data = new TextEncoder().encode('Wrong version');
-        const encrypted = await encryptBytes(data, key);
-        // Corrupt version byte (set to a very high number)
-        const view = new DataView(encrypted.buffer, encrypted.byteOffset, encrypted.length);
-        view.setUint16(0, 9999);
-        await expect(decryptBytes(encrypted, key)).rejects.toThrow('Invalid encryption version.');
-    });
-});

package/orm/tests/query-complex.test.d.ts

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