zibri 2.2.1 → 2.4.0

package/src/data-source/cascade-delete.test.ts

@@ -1,58 +1,33 @@
 import { beforeAll, afterAll, describe, it, expect } from '@jest/globals';
-import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
 
 import { Repository } from './repository';
-import { BaseEntity } from '../entity/base-entity.model';
-import { PostgresDataSource, PostgresOptions } from './data-sources/postgres-data-source.model';
-import { DataSource } from './decorators/data-source.decorator';
-import { MigrationEntity } from './migration/migration-entity.model';
-import { POSTGRES_TEST_IMAGE } from '../__testing__/constants';
 import { Child } from '../__testing__/mocks/entities/child.entity';
 import { Company } from '../__testing__/mocks/entities/company.entity';
 import { Parent } from '../__testing__/mocks/entities/parent.entity';
 import { Profile } from '../__testing__/mocks/entities/profile.entity';
 import { Role } from '../__testing__/mocks/entities/role.entity';
 import { User, UserCreateData, mockCreateUserData } from '../__testing__/mocks/entities/user.entity';
+import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { StartedTestServer, startTestServer } from '../__testing__/test-server/start-test-server.function';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
 import { inject } from '../di/inject.function';
-import { Newable } from '../types/newable.type';
-
-@DataSource()
-class TestDataSource extends PostgresDataSource {
-    options: PostgresOptions = {
-        host: 'localhost',
-        username: 'postgres',
-        password: 'password',
-        database: 'db',
-        synchronize: true
-    };
-    entities: Newable<BaseEntity>[] = [MigrationEntity, Parent, Child, User, Company, Profile, Role];
-}
 
 describe('cascade delete', () => {
-    let container: StartedPostgreSqlContainer;
-    let ds: TestDataSource;
+    let server: StartedTestServer;
 
     beforeAll(async () => {
-        container = await new PostgreSqlContainer(POSTGRES_TEST_IMAGE)
-            .withDatabase('db')
-            .withUsername('postgres')
-            .withPassword('password')
-            .start();
-        ds = inject(TestDataSource);
-        ds.options = {
-            ...ds.options,
-            port: container.getMappedPort(5432)
-        };
-        await ds.init();
-    }, 20000);
+        server = await startTestServer({
+            dataSources: [createTestDataSource({ entities: [...defaultTestServerEntities, Parent, Child, User, Company, Profile, Role] })]
+        });
+    }, 15000);
 
     afterAll(async () => {
-        await container.stop();
+        await server?.shutdown();
     });
 
     it('deletes children when parent removed', async () => {
-        const parentRepo: Repository<Parent> = ds.getRepository(Parent);
-        const childRepo: Repository<Child> = ds.getRepository(Child);
+        const parentRepo: Repository<Parent> = inject(repositoryTokenFor(Parent));
+        const childRepo: Repository<Child> = inject(repositoryTokenFor(Child));
         const parent: Parent = await parentRepo.create({ name: 'p1' });
         await childRepo.create({ name: 'c1', parent: { id: parent.id } });
         await childRepo.create({ name: 'c2', parent });
@@ -69,8 +44,8 @@ describe('cascade delete', () => {
     });
 
     it('deletes profile when user removed', async () => {
-        const userRepo: Repository<User, UserCreateData> = ds.getRepository(User);
-        const profileRepo: Repository<Profile> = ds.getRepository(Profile);
+        const userRepo: Repository<User, UserCreateData> = inject(repositoryTokenFor(User));
+        const profileRepo: Repository<Profile> = inject(repositoryTokenFor(Profile));
 
         const user: User = await userRepo.create(mockCreateUserData());
         const profile: Profile = await profileRepo.create({ bio: 'Bio', user });
@@ -87,8 +62,8 @@ describe('cascade delete', () => {
     });
 
     it('removes user from roles when user removed', async () => {
-        const userRepo: Repository<User, UserCreateData> = ds.getRepository(User);
-        const roleRepo: Repository<Role> = ds.getRepository(Role);
+        const userRepo: Repository<User, UserCreateData> = inject(repositoryTokenFor(User));
+        const roleRepo: Repository<Role> = inject(repositoryTokenFor(Role));
 
         const user1: User = await userRepo.create(mockCreateUserData());
         const user2: User = await userRepo.create(mockCreateUserData());

package/src/data-source/data-source-service.interface.ts

@@ -1,9 +1,7 @@
+import { AfterAppShutdown } from '../global/after-app-shutdown.interface';
+import { BeforeAppInit } from '../global/before-app-init.interface';
+
 /**
  * Interface for a data source service.
  */
-export interface DataSourceServiceInterface {
-    /**
-     * Initializes all data sources.
-     */
-    init: () => Promise<void>
-}
+export interface DataSourceServiceInterface extends BeforeAppInit, AfterAppShutdown {}

package/src/data-source/data-source.service.ts

@@ -1,66 +1,53 @@
 import { DataSourceServiceInterface } from './data-source-service.interface';
-import { BaseEntity } from '../entity/base-entity.model';
+import { ZibriApplication } from '../application';
 import { DataSourceInterface } from './data-sources/data-source.interface';
-import { OtpCredentials } from '../auth/2fa/methods/otp/otp-credentials.model';
-import { PasswordResetToken } from '../auth/models/password-reset-token.model';
-import { JwtCredentials } from '../auth/strategies/jwt/jwt-credentials.model';
-import { JwtRefreshToken } from '../auth/strategies/jwt/jwt-refresh-token.model';
-import { BackupEntity } from '../backup/backup-entity.model';
-import { BackupResourceEntity } from '../backup/backup-resource-entity.model';
+import { Inject } from '../di/decorators/inject.decorator';
+import { Injectable } from '../di/decorators/injectable.decorator';
 import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
 import { inject } from '../di/inject.function';
-import { MailingListSubscriber } from '../email/mailing-list/models/mailing-list-subscriber.model';
-import { MailingList } from '../email/mailing-list/models/mailing-list.model';
 import { GlobalRegistry } from '../global/global-registry';
-import { Log } from '../logging/log.model';
-import { LoggerInterface } from '../logging/logger.interface';
-import { Invoice } from '../plugin/invoicing/models/invoice.model';
-import { NumberInvoices } from '../plugin/invoicing/models/number-invoices.model';
-import { Payment } from '../plugin/payment/models/payment.model';
-import { Newable } from '../types/newable.type';
+import { type LoggerInterface } from '../logging/logger.interface';
+import { MetadataUtilities } from '../utilities/metadata.utilities';
 import { validateEntitiesRegistered } from '../utilities/validate-entities-registered.function';
 
 /**
  * Default data source service implementation of Zibri.
  */
+@Injectable({ register: 'onUse' })
 export class DataSourceService implements DataSourceServiceInterface {
-    private readonly logger: LoggerInterface;
+    private readonly dataSources: DataSourceInterface[] = [];
 
-    private readonly allowedOrphans: Newable<BaseEntity>[] = [
-        JwtRefreshToken,
-        JwtCredentials,
-        PasswordResetToken,
-        OtpCredentials,
-        MailingList,
-        MailingListSubscriber,
-        Log,
-        BackupResourceEntity,
-        BackupEntity,
-        NumberInvoices,
-        Invoice,
-        Payment
-    ];
-
-    constructor() {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface
+    ) { }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async init(): Promise<void> {
-        if (GlobalRegistry.dataSourceClasses.length) {
-            // eslint-disable-next-line stylistic/max-len
-            await this.logger.info(`initializes ${GlobalRegistry.dataSourceClasses.length} ${GlobalRegistry.dataSourceClasses.length > 1 ? 'data sources' : 'data source'}`);
+    async beforeAppInit(app: ZibriApplication): Promise<void> {
+        const { dataSources } = app.options;
+        if (dataSources.length) {
+            await this.logger.info(`initializes ${dataSources.length} ${dataSources.length > 1 ? 'data sources' : 'data source'}`);
         }
 
-        for (const dataSourceClass of GlobalRegistry.dataSourceClasses) {
+        for (const dataSourceClass of dataSources) {
             const dataSource: DataSourceInterface = inject(dataSourceClass);
+            if (!MetadataUtilities.getFilePath(dataSourceClass)) {
+                throw new Error(`The data source ${dataSourceClass.name} is not decorated with @DataSource.`);
+            }
+            this.dataSources.push(dataSource);
             await this.logger.info(`  - ${dataSourceClass.name} (${dataSource.entities.length} entities)`);
             await dataSource.init();
         }
 
         validateEntitiesRegistered(
             this.constructor.name,
-            ...GlobalRegistry.entityClasses.filter(e => !this.allowedOrphans.includes(e))
+            app,
+            ...GlobalRegistry.entityClasses.filter(e => !(MetadataUtilities.getEntityMetadata(e)?.allowOrphan ?? false))
         );
     }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async afterAppShutdown(): Promise<void> {
+        await Promise.all(this.dataSources.map(ds => ds.shutDown()));
+    }
 }

package/src/data-source/data-sources/data-source.interface.ts

@@ -1,5 +1,3 @@
-import { IsolationLevel } from 'typeorm/driver/types/IsolationLevel';
-
 import { BackupResourceInterface } from '../../backup/backup-resource.interface';
 import { BaseEntity } from '../../entity/base-entity.model';
 import { PropertyMetadataInput, PropertyMetadata, RelationMetadata } from '../../entity/decorators/property.decorator';
@@ -10,6 +8,16 @@ import { Migration } from '../migration/migration.model';
 import { Repository } from '../repository';
 import { Transaction } from '../transaction/transaction.model';
 
+/**
+ * The isolation level of any data source calls made inside a transaction.
+ */
+export enum IsolationLevel {
+    READ_UNCOMMITTED = 'READ UNCOMMITTED',
+    READ_COMMITTED = 'READ COMMITTED',
+    REPEATABLE_READ = 'REPEATABLE READ',
+    SERIALIZABLE = 'SERIALIZABLE'
+}
+
 /**
  * Definition for a data source.
  */
@@ -29,6 +37,12 @@ export interface DataSourceInterface extends BackupResourceInterface {
      */
     init: () => Promise<void>,
 
+    /**
+     * Shuts down the data source.
+     * Should be called from the data source service AfterAppShutdown hook.
+     */
+    shutDown: () => Promise<void>,
+
     /**
      * Gets a repository to manage the provided entity class in the data source.
      * @param cls - The entity class to get the repository for.
@@ -78,4 +92,34 @@ export interface DataSourceInterface extends BackupResourceInterface {
         },
         transaction: Transaction
     ) => Promise<void>
+}
+
+/**
+ * Checks whether or not the given value is a data source.
+ * @param value - The value to check.
+ * @returns True if all keys of the DataSourceInterface are present, false otherwise.
+ */
+export function isDataSource(value: unknown): value is DataSourceInterface {
+    if (typeof value !== 'object') {
+        return false;
+    }
+    if (value == undefined) {
+        return false;
+    }
+
+    const keys: (keyof DataSourceInterface)[] = [
+        'addPropertyToEntity',
+        'changePropertyOfEntity',
+        'createBackupData',
+        'entities',
+        'getRepository',
+        'init',
+        'migrations',
+        'restoreBackup',
+        'runMigrations',
+        'shutDown',
+        'startTransaction'
+    ];
+
+    return !keys.find(key => !(key in value));
 }

package/src/data-source/data-sources/postgres-data-source.model.ts

@@ -3,17 +3,17 @@ import { PassThrough, Readable, Writable } from 'node:stream';
 
 import { DataSource as TODataSource, Repository as TORepository, EntityMetadata as TOEntityMetadata, EntitySchema, EntitySchemaColumnOptions, QueryRunner, EntitySchemaRelationOptions, Table, TableColumnOptions, TableColumn, EntityTarget } from 'typeorm';
 import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions.js';
-import { IsolationLevel } from 'typeorm/driver/types/IsolationLevel.js';
 import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata.js';
 import { OnDeleteType } from 'typeorm/metadata/types/OnDeleteType.js';
 import { OnUpdateType } from 'typeorm/metadata/types/OnUpdateType.js';
 
-import { DataSourceInterface } from './data-source.interface';
+import { DataSourceInterface, IsolationLevel } from './data-source.interface';
 import { ChangeSetRepository } from '../../change-sets/change-set-repository';
 import { isChangeSetEntityNewable, ChangeSetEntity } from '../../change-sets/models/change-set-entity.model';
 import { isSoftDeleteEntityNewable, SoftDeleteEntity } from '../../change-sets/models/soft-delete-entity.model';
 import { SoftDeleteRepository } from '../../change-sets/soft-delete-repository';
 import { repositoryTokenFor } from '../../di/decorators/inject-repository.decorator';
+import { Inject } from '../../di/decorators/inject.decorator';
 import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
 import { inject } from '../../di/inject.function';
 import { register } from '../../di/register.function';
@@ -24,7 +24,7 @@ import { FilePropertyMetadata } from '../../entity/models/file-property-metadata
 import { Relation } from '../../entity/models/relation.enum';
 import { StringPropertyMetadata } from '../../entity/models/string-property-metadata.model';
 import { GlobalRegistry } from '../../global/global-registry';
-import { LoggerInterface } from '../../logging/logger.interface';
+import { type LoggerInterface } from '../../logging/logger.interface';
 import { ExcludeStrict } from '../../types/exclude-strict.type';
 import { Newable } from '../../types/newable.type';
 import { OmitStrict } from '../../types/omit-strict.type';
@@ -32,6 +32,7 @@ import { Version } from '../../types/version.type';
 import { compareVersion } from '../../utilities/compare-versions.function';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
 import { ObjectUtilities } from '../../utilities/object.utilities';
+import { getDefaultBeforeReturnHook, getDefaultBeforeSaveHook } from '../hooks/hooks.default';
 import { MigrationEntity } from '../migration/migration-entity.model';
 import { Migration } from '../migration/migration.model';
 import { ColumnType } from '../models/column-type.model';
@@ -92,14 +93,11 @@ export abstract class PostgresDataSource implements DataSourceInterface {
      * The internal typeorm data source.
      */
     protected ds?: TODataSource;
-    /**
-     * A logger.
-     */
-    protected readonly logger: LoggerInterface;
 
-    constructor() {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface
+    ) { }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     createBackupData(): Readable {
@@ -166,6 +164,12 @@ export abstract class PostgresDataSource implements DataSourceInterface {
             throw new Error('The postgres data source has already been initialized.');
         }
 
+        if (this.options.username === 'postgres' && this.options.password === 'password') {
+            await this.logger.warn(
+                `The data source "${this.constructor.name}" uses the default credentials, you probably want to change that.`
+            );
+        }
+
         for (const entityClass of this.entities) {
             register({
                 token: repositoryTokenFor(entityClass),
@@ -190,6 +194,11 @@ export abstract class PostgresDataSource implements DataSourceInterface {
         }
     }
 
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async shutDown(): Promise<void> {
+        await this.ds?.destroy();
+    }
+
     /**
      * Gets entity schemas for the entities of this data source.
      * @returns Typeorm entity schemas.
@@ -212,7 +221,11 @@ export abstract class PostgresDataSource implements DataSourceInterface {
         }
         const props: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(cls);
 
-        const numberOfPrimaryKeys: number = ObjectUtilities.values(props).filter(d => (d as StringPropertyMetadata).primary).length;
+        const numberOfPrimaryKeys: number = ObjectUtilities
+            .values(props)
+            // eslint-disable-next-line typescript/no-explicit-any
+            .filter(d => (d as StringPropertyMetadata<any, any, any, any, any>).primary)
+            .length;
         if (numberOfPrimaryKeys === 0) {
             throw new Error(`no primary key specified for entity "${cls.name}".`);
         }
@@ -349,13 +362,20 @@ export abstract class PostgresDataSource implements DataSourceInterface {
                     nullable,
                     generated: metadata.primary ? 'increment' : undefined,
                     ...metadata,
-                    type: this.columnTypeMapping[metadata.type],
+                    type: metadata.format ?? this.columnTypeMapping[metadata.type],
                     default: undefined,
                     transformer: {
                         // eslint-disable-next-line unicorn/no-null
-                        to: (v: number | null) => v != null ? String(v) : null,
-                        // eslint-disable-next-line unicorn/no-null
-                        from: (v: string | null) => v != null ? Number(v) : undefined
+                        to: (v: number | bigint | null) => v != null ? String(v) : null,
+                        from: (v: string | null) => {
+                            if (v == undefined) {
+                                return v;
+                            }
+                            if (metadata.format === 'bigint') {
+                                return BigInt(v);
+                            }
+                            return Number(v);
+                        }
                     }
                 };
             }
@@ -388,17 +408,30 @@ export abstract class PostgresDataSource implements DataSourceInterface {
             return new SoftDeleteRepository(
                 cls,
                 repo as unknown as TORepository<SoftDeleteEntity>,
-                this.logger
+                this.logger,
+                this,
+                getDefaultBeforeSaveHook(),
+                getDefaultBeforeReturnHook()
             ) as unknown as Repository<T>;
         }
         if (isChangeSetEntityNewable(cls)) {
             return new ChangeSetRepository(
                 cls,
                 repo as unknown as TORepository<ChangeSetEntity>,
-                this.logger
+                this.logger,
+                this,
+                getDefaultBeforeSaveHook(),
+                getDefaultBeforeReturnHook()
             ) as unknown as Repository<T>;
         }
-        return new Repository(cls, repo, this.logger);
+        return new Repository<T>(
+            cls,
+            repo,
+            this.logger,
+            this,
+            getDefaultBeforeSaveHook(),
+            getDefaultBeforeReturnHook()
+        );
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -435,6 +468,7 @@ export abstract class PostgresDataSource implements DataSourceInterface {
     async runMigrations(): Promise<void> {
         await this.createMigrationTableIfNotExists();
 
+        // we need to dynamically inject here because the repositories aren't ready in the constructor.
         const migrationsRepository: Repository<MigrationEntity> = inject(repositoryTokenFor(MigrationEntity));
         const finishedMigrationVersions: string[] = (await migrationsRepository.findAll()).map(m => m.version);
         const allMigrations: MigrationWithName[] = this.migrations.map(m => ({ migration: inject(m), name: m.name }));

package/src/data-source/decorators/data-source.decorator.ts

@@ -1,7 +1,6 @@
 import { GlobalRegistry } from '../../global/global-registry';
 import { Newable } from '../../types/newable.type';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
-import { DataSourceInterface } from '../data-sources/data-source.interface';
 
 /**
  * Marks a class to be a data source.
@@ -11,10 +10,10 @@ export function DataSource(): ClassDecorator {
         // eslint-disable-next-line unicorn/error-message
         const stack: string = new Error().stack ?? '';
         MetadataUtilities.setFilePath(target, stack);
+
         GlobalRegistry.injectables.push({
             token: target as unknown as Newable<unknown>,
             useClass: target as unknown as Newable<unknown>
         });
-        GlobalRegistry.dataSourceClasses.push(target as unknown as Newable<DataSourceInterface>);
     };
 }