@tstdl/base 0.93.87 → 0.93.90

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

@@ -0,0 +1,115 @@
+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 { 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 { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository CTI Soft Delete (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_cti_soft_delete';
+    let Base = class Base extends Entity {
+        type;
+        baseName;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'type' }),
+        __metadata("design:type", String)
+    ], Base.prototype, "type", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Base.prototype, "baseName", void 0);
+    Base = __decorate([
+        Table('bases', { schema }),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], Base);
+    let Subtype = class Subtype extends Base {
+        subData;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Subtype.prototype, "subData", void 0);
+    Subtype = __decorate([
+        Table('subtypes', { schema }),
+        ChildEntity('subtype')
+    ], Subtype);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1',
+                port: 5432,
+                user: 'tstdl',
+                password: 'wf7rq6glrk5jykne',
+                database: 'tstdl',
+            }
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('subtypes')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type TEXT NOT NULL,
+        base_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('subtypes')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'subtype'),
+        sub_data TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('bases')} (id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should soft delete from subtype repository', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repo = injectRepository(Subtype);
+            const entity = await repo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
+            await repo.delete(entity.id);
+            const { rows } = await db.execute(sql `SELECT delete_timestamp FROM ${sql.identifier(schema)}.${sql.identifier('bases')} WHERE id = ${entity.id}`);
+            expect(rows[0].delete_timestamp).not.toBeNull();
+            expect(await repo.has(entity.id)).toBe(false);
+            expect(await repo.loadManyByQuery({ id: entity.id }).then((r) => r[0])).toBeUndefined();
+        });
+    });
+    test('should polymorphically filter soft deleted entities', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const baseRepo = injectRepository(Base);
+            const subRepo = injectRepository(Subtype);
+            const s1 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Active', subData: 'S1' }));
+            const s2 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Deleted', subData: 'S2' }));
+            await subRepo.delete(s2.id);
+            const allActive = await baseRepo.loadAll({ includeSubclasses: true });
+            expect(allActive).toHaveLength(1);
+            expect(allActive[0].id).toBe(s1.id);
+            const allIncludingDeleted = await baseRepo.loadAll({ includeSubclasses: true, withDeleted: true });
+            expect(allIncludingDeleted).toHaveLength(2);
+        });
+    });
+});

package/orm/tests/repository-cti-transactions.test.d.ts

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

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

@@ -0,0 +1,126 @@
+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 { beforeAll, describe, expect, test } from 'vitest';
+import { sql } from 'drizzle-orm';
+import { StringProperty } from '../../schema/index.js';
+import { Entity } from '../entity.js';
+import { Column, Inheritance, ChildEntity, Table } from '../decorators.js';
+import { getRepository } from '../server/repository.js';
+import { configureOrm, Database } from '../server/index.js';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { Transactional } from '../server/transactional.js';
+import { Singleton } from '../../injector/decorators.js';
+describe('ORM Repository CTI Transactions (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_cti_transactions';
+    let Parent = class Parent extends Entity {
+        type;
+        name;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'type' }),
+        __metadata("design:type", String)
+    ], Parent.prototype, "type", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Parent.prototype, "name", void 0);
+    Parent = __decorate([
+        Table('parents', { schema }),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], Parent);
+    let Child = class Child extends Parent {
+        childData;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Child.prototype, "childData", void 0);
+    Child = __decorate([
+        Table('children', { schema }),
+        ChildEntity('child')
+    ], Child);
+    let TestService = class TestService extends Transactional {
+        #childRepo = getRepository(Child);
+        async createTwo(name1, name2, failSecond) {
+            await this.transaction(async (tx) => {
+                const repo = injector.resolve(this.#childRepo).withTransaction(tx);
+                await repo.insert(Object.assign(new Child(), { name: name1, childData: 'data1' }));
+                if (failSecond) {
+                    throw new Error('Planned failure');
+                }
+                await repo.insert(Object.assign(new Child(), { name: name2, childData: 'data2' }));
+            });
+        }
+    };
+    TestService = __decorate([
+        Singleton()
+    ], TestService);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1',
+                port: 5432,
+                user: 'tstdl',
+                password: 'wf7rq6glrk5jykne',
+                database: 'tstdl',
+            }
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('children')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('parents')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('parents')} (
+        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('children')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'child'),
+        child_data TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('parents')} (id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should rollback inheritance inserts across multiple tables on service error', async () => {
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TestService);
+            await expect(service.createTwo('ShouldRollback', 'Fails', true)).rejects.toThrow('Planned failure');
+            const { rows: parentRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('parents')}`);
+            const { rows: childRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('children')}`);
+            expect(parentRows).toHaveLength(0);
+            expect(childRows).toHaveLength(0);
+        });
+    });
+    test('should commit inheritance inserts across multiple tables on success', async () => {
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TestService);
+            await service.createTwo('C1', 'C2', false);
+            const { rows: parentRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('parents')}`);
+            const { rows: childRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('children')}`);
+            expect(parentRows).toHaveLength(2);
+            expect(childRows).toHaveLength(2);
+        });
+    });
+});

package/orm/tests/repository-cti-upsert-many.test.d.ts

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

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

@@ -0,0 +1,127 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository CTI UpsertMany (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_cti_upsert_many';
+    let Item = class Item extends Entity {
+        type;
+        title;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'type' }),
+        __metadata("design:type", String)
+    ], Item.prototype, "type", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Item.prototype, "title", void 0);
+    Item = __decorate([
+        Table('items', { schema }),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], Item);
+    let Book = class Book extends Item {
+        author;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Book.prototype, "author", void 0);
+    Book = __decorate([
+        Table('books', { schema }),
+        ChildEntity('book')
+    ], Book);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1',
+                port: 5432,
+                user: 'tstdl',
+                password: 'wf7rq6glrk5jykne',
+                database: 'tstdl',
+            }
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('books')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('items')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('items')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type TEXT NOT NULL,
+        title 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('books')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'book'),
+        author TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('items')} (id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should upsertMany child entities (insert and update mixed)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const bookRepo = injectRepository(Book);
+            // 1. Insert initial books
+            const book1 = Object.assign(new Book(), { title: 'Book 1', author: 'Author 1' });
+            const book2 = Object.assign(new Book(), { title: 'Book 2', author: 'Author 2' });
+            const [inserted1, inserted2] = await bookRepo.insertMany([book1, book2]);
+            // 2. Prepare upsert payload: update book1, new book3
+            const update1 = Object.assign(new Book(), { id: inserted1.id, title: 'Book 1 Updated', author: 'Author 1 Updated' });
+            const book3 = Object.assign(new Book(), { title: 'Book 3', author: 'Author 3' });
+            const results = await bookRepo.upsertMany('id', [update1, book3]);
+            expect(results).toHaveLength(2);
+            const updated1 = results.find((b) => b.id === inserted1.id);
+            const inserted3 = results.find((b) => b.title === 'Book 3');
+            expect(updated1).toBeDefined();
+            expect(updated1.title).toBe('Book 1 Updated');
+            expect(updated1.author).toBe('Author 1 Updated');
+            expect(inserted3).toBeDefined();
+            expect(inserted3.id).toBeDefined();
+            expect(inserted3.author).toBe('Author 3');
+            // Verify book2 is untouched
+            const loaded2 = await bookRepo.load(inserted2.id);
+            expect(loaded2.title).toBe('Book 2');
+        });
+    });
+    test('should polymorphic tryLoadByQuery', async () => {
+        await runInInjectionContext(injector, async () => {
+            const itemRepo = injectRepository(Item);
+            const bookRepo = injectRepository(Book);
+            await bookRepo.insert(Object.assign(new Book(), { title: 'Unique Book', author: 'Unique Author' }));
+            // Load via Item repo using a book-specific property (should fail if not joined, but here we query by title)
+            // Querying by book-specific property requires casting query or using raw sql if repository type doesn't have it.
+            // But we can query by base property 'title'.
+            const loaded = await itemRepo.tryLoadByQuery({ title: 'Unique Book' }, { includeSubclasses: true });
+            expect(loaded).toBeDefined();
+            expect(loaded).toBeInstanceOf(Book);
+            expect(loaded.author).toBe('Unique Author');
+        });
+    });
+});

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

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