@spytecgps/nova-orm 1.2.23 → 1.2.24

package/dist/repositories/appFeatures/createAppFeatureType.d.ts

@@ -1,5 +1,5 @@
-import { AppFeatureType } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { CreateAppFeatureTypeParams } from '../../types/appFeatures';
-import { Logger } from '../../types/logger';
-export declare const createAppFeatureType: (novaDataSource: NovaDataSource, params: CreateAppFeatureTypeParams, logger: Logger) => Promise<AppFeatureType>;
+import { AppFeatureType } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { CreateAppFeatureTypeParams } from '../../types/appFeatures';
+import { Logger } from '../../types/logger';
+export declare const createAppFeatureType: (novaDataSource: NovaDataSource, params: CreateAppFeatureTypeParams, logger: Logger) => Promise<AppFeatureType>;

package/dist/repositories/appFeatures/createAppFeatureType.js

@@ -1,16 +1,16 @@
-import { AppFeatureType } from '../../entities';
-export const createAppFeatureType = async (novaDataSource, params, logger) => {
-    if (!params?.description || !params?.name) {
-        logger.warn({ params }, 'AppFeaturesRepository::createAppFeatureType - missing required parameters');
-        return null;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const appFeatureTypeRepository = dataSource.getRepository(AppFeatureType);
-        const newAppFeature = {
-            ...params,
-            statusId: params.statusId ?? 1,
-        };
-        return await appFeatureTypeRepository.save(newAppFeature);
-    }, 'AppFeaturesRepository::createAppFeatureType');
-};
+import { AppFeatureType } from '../../entities';
+export const createAppFeatureType = async (novaDataSource, params, logger) => {
+    if (!params?.description || !params?.name) {
+        logger.warn({ params }, 'AppFeaturesRepository::createAppFeatureType - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const appFeatureTypeRepository = dataSource.getRepository(AppFeatureType);
+        const newAppFeature = {
+            ...params,
+            statusId: params.statusId ?? 1,
+        };
+        return await appFeatureTypeRepository.save(newAppFeature);
+    }, 'AppFeaturesRepository::createAppFeatureType');
+};
 //# sourceMappingURL=createAppFeatureType.js.map

package/dist/repositories/appFeatures/createClientAppFeature.d.ts

@@ -1,5 +1,5 @@
-import { ClientAppFeature } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { CreateClientAppFeatureParams } from '../../types/appFeatures';
-import { Logger } from '../../types/logger';
-export declare const createClientAppFeature: (novaDataSource: NovaDataSource, params: CreateClientAppFeatureParams, logger: Logger) => Promise<ClientAppFeature>;
+import { ClientAppFeature } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { CreateClientAppFeatureParams } from '../../types/appFeatures';
+import { Logger } from '../../types/logger';
+export declare const createClientAppFeature: (novaDataSource: NovaDataSource, params: CreateClientAppFeatureParams, logger: Logger) => Promise<ClientAppFeature>;

package/dist/repositories/appFeatures/createClientAppFeature.js

@@ -1,16 +1,16 @@
-import { ClientAppFeature } from '../../entities';
-export const createClientAppFeature = async (novaDataSource, params, logger) => {
-    if (!params?.clientId || !params?.appFeatureTypeId || !params.entityId) {
-        logger.warn({ params }, 'AppFeaturesRepository::createClientAppFeature - missing required parameters');
-        return null;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const clientAppFeatureRepository = dataSource.getRepository(ClientAppFeature);
-        const newClientAppFeature = {
-            ...params,
-            statusId: params.statusId ?? 1,
-        };
-        return await clientAppFeatureRepository.save(newClientAppFeature);
-    }, 'AppFeaturesRepository::createClientAppFeature');
-};
+import { ClientAppFeature } from '../../entities';
+export const createClientAppFeature = async (novaDataSource, params, logger) => {
+    if (!params?.clientId || !params?.appFeatureTypeId || !params.entityId) {
+        logger.warn({ params }, 'AppFeaturesRepository::createClientAppFeature - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientAppFeatureRepository = dataSource.getRepository(ClientAppFeature);
+        const newClientAppFeature = {
+            ...params,
+            statusId: params.statusId ?? 1,
+        };
+        return await clientAppFeatureRepository.save(newClientAppFeature);
+    }, 'AppFeaturesRepository::createClientAppFeature');
+};
 //# sourceMappingURL=createClientAppFeature.js.map

package/dist/repositories/appFeatures/getClientAppFeatures.d.ts

@@ -1,5 +1,5 @@
-import { ClientAppFeature } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { GetClientAppFeaturesParams } from '../../types/appFeatures';
-import { Logger } from '../../types/logger';
-export declare const getClientAppFeatures: (novaDataSource: NovaDataSource, params: GetClientAppFeaturesParams, logger: Logger) => Promise<ClientAppFeature[]>;
+import { ClientAppFeature } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { GetClientAppFeaturesParams } from '../../types/appFeatures';
+import { Logger } from '../../types/logger';
+export declare const getClientAppFeatures: (novaDataSource: NovaDataSource, params: GetClientAppFeaturesParams, logger: Logger) => Promise<ClientAppFeature[]>;

package/dist/repositories/appFeatures/getClientAppFeatures.js

@@ -1,45 +1,45 @@
-import { ClientAppFeature } from '../../entities';
-export const getClientAppFeatures = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.clientId &&
-        !params?.filters?.appFeatureTypeId &&
-        !params.filters?.entityId &&
-        !params.filters?.statusId) {
-        logger.warn({ params }, 'AppFeaturesRepository::getClientAppFeatures - missing required parameters');
-        return [];
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const clientAppFeaturesRepository = dataSource.getRepository(ClientAppFeature);
-        let queryBuilder = clientAppFeaturesRepository.createQueryBuilder('clientAppFeature');
-        if (queryRunner) {
-            queryBuilder = queryBuilder.setQueryRunner(queryRunner);
-        }
-        if (params.projectionOptions?.withAppFeatureType) {
-            queryBuilder = queryBuilder.leftJoinAndSelect('clientAppFeature.appFeatureType', 'appFeatureType');
-        }
-        if (params.filters.clientId) {
-            queryBuilder = queryBuilder.andWhere(`clientAppFeature.clientId = :clientId`, {
-                clientId: params.filters.clientId,
-            });
-        }
-        if (params.filters.appFeatureTypeId) {
-            queryBuilder = queryBuilder.andWhere(`clientAppFeature.appFeatureTypeId = :appFeatureTypeId`, {
-                appFeatureTypeId: params.filters.appFeatureTypeId,
-            });
-        }
-        if (params.filters.entityId) {
-            queryBuilder = queryBuilder.andWhere(`clientAppFeature.entityId = :entityId`, {
-                entityId: params.filters.entityId,
-            });
-        }
-        if (params.filters.statusId) {
-            queryBuilder = queryBuilder.andWhere(`clientAppFeature.statusId = :statusId`, {
-                statusId: params.filters.statusId,
-            });
-        }
-        const result = await queryBuilder.getMany();
-        return result;
-    }, 'AppFeaturesRepository::getClientAppFeatures', dbQueryRunner);
-};
+import { ClientAppFeature } from '../../entities';
+export const getClientAppFeatures = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId &&
+        !params?.filters?.appFeatureTypeId &&
+        !params.filters?.entityId &&
+        !params.filters?.statusId) {
+        logger.warn({ params }, 'AppFeaturesRepository::getClientAppFeatures - missing required parameters');
+        return [];
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const clientAppFeaturesRepository = dataSource.getRepository(ClientAppFeature);
+        let queryBuilder = clientAppFeaturesRepository.createQueryBuilder('clientAppFeature');
+        if (queryRunner) {
+            queryBuilder = queryBuilder.setQueryRunner(queryRunner);
+        }
+        if (params.projectionOptions?.withAppFeatureType) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('clientAppFeature.appFeatureType', 'appFeatureType');
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.clientId = :clientId`, {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (params.filters.appFeatureTypeId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.appFeatureTypeId = :appFeatureTypeId`, {
+                appFeatureTypeId: params.filters.appFeatureTypeId,
+            });
+        }
+        if (params.filters.entityId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.entityId = :entityId`, {
+                entityId: params.filters.entityId,
+            });
+        }
+        if (params.filters.statusId) {
+            queryBuilder = queryBuilder.andWhere(`clientAppFeature.statusId = :statusId`, {
+                statusId: params.filters.statusId,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'AppFeaturesRepository::getClientAppFeatures', dbQueryRunner);
+};
 //# sourceMappingURL=getClientAppFeatures.js.map

package/dist/repositories/appFeatures/index.d.ts

@@ -1,37 +1,37 @@
-import { AppFeatureType, ClientAppFeature } from '../../entities';
-import { CreateAppFeatureTypeParams, CreateClientAppFeatureParams, GetClientAppFeaturesParams } from '../../types/appFeatures';
-import { BaseRepository } from '../baseRepository';
-export declare class AppFeaturesRepository extends BaseRepository {
-    /**
-     * Create a new app feature type
-     * @param params - The parameters to create the app feature type
-     * params.id - The id of the app feature type, optional. If not provided, it will be auto-generated
-     * params.name - The name of the app feature type, required
-     * params.description - The description of the app feature type, required
-     * params.statusId - The status id of the app feature type, optional, default to 1
-     * @returns The created app feature type
-     */
-    createAppFeatureType(params: CreateAppFeatureTypeParams): Promise<AppFeatureType>;
-    /**
-     * Create a new client app feature
-     * @param params - The parameters to create the client app feature
-     * params.clientId: The client id of the client app feature, required
-     * params.appFeatureTypeId: The app feature type id of the client app feature, required
-     * params.entityId: The entity id of the client app feature, required
-     * params.statusId: The status id of the client app feature, optional, default to 1
-     * @returns The created client app feature
-     */
-    createClientAppFeature(params: CreateClientAppFeatureParams): Promise<ClientAppFeature>;
-    /**
-     * Get client app features
-     * @param params - The parameters to get client app features
-     * One of the following filters is required:
-     * params.filters.clientId: The client id to filter, optional
-     * params.filters.appFeatureTypeId: The app feature type id to filter, optional
-     * params.filters.entityId: The entity id to filter, optional
-     * params.filters.statusId: The status id to filter, optional
-     * params.projectionOptions.withAppFeatureType: Whether to include app feature type relation in the result
-     * @returns The client app features
-     */
-    getClientAppFeatures(params: GetClientAppFeaturesParams): Promise<ClientAppFeature[]>;
-}
+import { AppFeatureType, ClientAppFeature } from '../../entities';
+import { CreateAppFeatureTypeParams, CreateClientAppFeatureParams, GetClientAppFeaturesParams } from '../../types/appFeatures';
+import { BaseRepository } from '../baseRepository';
+export declare class AppFeaturesRepository extends BaseRepository {
+    /**
+     * Create a new app feature type
+     * @param params - The parameters to create the app feature type
+     * params.id - The id of the app feature type, optional. If not provided, it will be auto-generated
+     * params.name - The name of the app feature type, required
+     * params.description - The description of the app feature type, required
+     * params.statusId - The status id of the app feature type, optional, default to 1
+     * @returns The created app feature type
+     */
+    createAppFeatureType(params: CreateAppFeatureTypeParams): Promise<AppFeatureType>;
+    /**
+     * Create a new client app feature
+     * @param params - The parameters to create the client app feature
+     * params.clientId: The client id of the client app feature, required
+     * params.appFeatureTypeId: The app feature type id of the client app feature, required
+     * params.entityId: The entity id of the client app feature, required
+     * params.statusId: The status id of the client app feature, optional, default to 1
+     * @returns The created client app feature
+     */
+    createClientAppFeature(params: CreateClientAppFeatureParams): Promise<ClientAppFeature>;
+    /**
+     * Get client app features
+     * @param params - The parameters to get client app features
+     * One of the following filters is required:
+     * params.filters.clientId: The client id to filter, optional
+     * params.filters.appFeatureTypeId: The app feature type id to filter, optional
+     * params.filters.entityId: The entity id to filter, optional
+     * params.filters.statusId: The status id to filter, optional
+     * params.projectionOptions.withAppFeatureType: Whether to include app feature type relation in the result
+     * @returns The client app features
+     */
+    getClientAppFeatures(params: GetClientAppFeaturesParams): Promise<ClientAppFeature[]>;
+}

package/dist/repositories/appFeatures/index.js

@@ -1,58 +1,58 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { BaseRepository } from '../baseRepository';
-import { createAppFeatureType } from './createAppFeatureType';
-import { createClientAppFeature } from './createClientAppFeature';
-import { getClientAppFeatures } from './getClientAppFeatures';
-export class AppFeaturesRepository extends BaseRepository {
-    /**
-     * Create a new app feature type
-     * @param params - The parameters to create the app feature type
-     * params.id - The id of the app feature type, optional. If not provided, it will be auto-generated
-     * params.name - The name of the app feature type, required
-     * params.description - The description of the app feature type, required
-     * params.statusId - The status id of the app feature type, optional, default to 1
-     * @returns The created app feature type
-     */
-    async createAppFeatureType(params) {
-        this.logger.trace('AppFeaturesRepository::createAppFeatureType started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await createAppFeatureType(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'AppFeaturesRepository::createAppFeatureType result');
-        return result;
-    }
-    /**
-     * Create a new client app feature
-     * @param params - The parameters to create the client app feature
-     * params.clientId: The client id of the client app feature, required
-     * params.appFeatureTypeId: The app feature type id of the client app feature, required
-     * params.entityId: The entity id of the client app feature, required
-     * params.statusId: The status id of the client app feature, optional, default to 1
-     * @returns The created client app feature
-     */
-    async createClientAppFeature(params) {
-        this.logger.trace('AppFeaturesRepository::createClientAppFeature started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await createClientAppFeature(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'AppFeaturesRepository::createClientAppFeature result');
-        return result;
-    }
-    /**
-     * Get client app features
-     * @param params - The parameters to get client app features
-     * One of the following filters is required:
-     * params.filters.clientId: The client id to filter, optional
-     * params.filters.appFeatureTypeId: The app feature type id to filter, optional
-     * params.filters.entityId: The entity id to filter, optional
-     * params.filters.statusId: The status id to filter, optional
-     * params.projectionOptions.withAppFeatureType: Whether to include app feature type relation in the result
-     * @returns The client app features
-     */
-    async getClientAppFeatures(params) {
-        this.logger.trace('AppFeaturesRepository::getClientAppFeatures started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getClientAppFeatures(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'AppFeaturesRepository::getClientAppFeatures result');
-        return result;
-    }
-}
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createAppFeatureType } from './createAppFeatureType';
+import { createClientAppFeature } from './createClientAppFeature';
+import { getClientAppFeatures } from './getClientAppFeatures';
+export class AppFeaturesRepository extends BaseRepository {
+    /**
+     * Create a new app feature type
+     * @param params - The parameters to create the app feature type
+     * params.id - The id of the app feature type, optional. If not provided, it will be auto-generated
+     * params.name - The name of the app feature type, required
+     * params.description - The description of the app feature type, required
+     * params.statusId - The status id of the app feature type, optional, default to 1
+     * @returns The created app feature type
+     */
+    async createAppFeatureType(params) {
+        this.logger.trace('AppFeaturesRepository::createAppFeatureType started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await createAppFeatureType(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AppFeaturesRepository::createAppFeatureType result');
+        return result;
+    }
+    /**
+     * Create a new client app feature
+     * @param params - The parameters to create the client app feature
+     * params.clientId: The client id of the client app feature, required
+     * params.appFeatureTypeId: The app feature type id of the client app feature, required
+     * params.entityId: The entity id of the client app feature, required
+     * params.statusId: The status id of the client app feature, optional, default to 1
+     * @returns The created client app feature
+     */
+    async createClientAppFeature(params) {
+        this.logger.trace('AppFeaturesRepository::createClientAppFeature started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await createClientAppFeature(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AppFeaturesRepository::createClientAppFeature result');
+        return result;
+    }
+    /**
+     * Get client app features
+     * @param params - The parameters to get client app features
+     * One of the following filters is required:
+     * params.filters.clientId: The client id to filter, optional
+     * params.filters.appFeatureTypeId: The app feature type id to filter, optional
+     * params.filters.entityId: The entity id to filter, optional
+     * params.filters.statusId: The status id to filter, optional
+     * params.projectionOptions.withAppFeatureType: Whether to include app feature type relation in the result
+     * @returns The client app features
+     */
+    async getClientAppFeatures(params) {
+        this.logger.trace('AppFeaturesRepository::getClientAppFeatures started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await getClientAppFeatures(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'AppFeaturesRepository::getClientAppFeatures result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/repositories/assetCategories/getAssetCategories.d.ts

@@ -1,3 +1,3 @@
-import { AssetCategory } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-export declare const getAssetCategories: (novaDataSource: NovaDataSource, forceUseReplica?: boolean) => Promise<AssetCategory[]>;
+import { AssetCategory } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+export declare const getAssetCategories: (novaDataSource: NovaDataSource, forceUseReplica?: boolean) => Promise<AssetCategory[]>;

package/dist/repositories/assetCategories/getAssetCategories.js

@@ -1,19 +1,19 @@
-import { AssetCategory } from '../../entities';
-export const getAssetCategories = async (novaDataSource, forceUseReplica) => {
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams({
-        queryOptions: {
-            forceUseReplica,
-        },
-    });
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const assetCategoriesRepository = dataSource.getRepository(AssetCategory);
-        const queryBuilder = assetCategoriesRepository.createQueryBuilder('assetCategory');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const result = await queryBuilder.getMany();
-        return result;
-    }, 'AssetcategoriesRepository::getAssetCategories', dbQueryRunner);
-};
+import { AssetCategory } from '../../entities';
+export const getAssetCategories = async (novaDataSource, forceUseReplica) => {
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams({
+        queryOptions: {
+            forceUseReplica,
+        },
+    });
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const assetCategoriesRepository = dataSource.getRepository(AssetCategory);
+        const queryBuilder = assetCategoriesRepository.createQueryBuilder('assetCategory');
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'AssetcategoriesRepository::getAssetCategories', dbQueryRunner);
+};
 //# sourceMappingURL=getAssetCategories.js.map

package/dist/repositories/assetCategories/index.d.ts

@@ -1,9 +1,9 @@
-import { AssetCategory } from '../../entities';
-import { BaseRepository } from '../baseRepository';
-export declare class AssetCategoriesRepository extends BaseRepository {
-    /**
-     * Get all asset categories
-     * @returns {Promise<AssetCategory[]>} The asset categories
-     */
-    getAssetCategories(forceUseReplica?: boolean): Promise<AssetCategory[]>;
-}
+import { AssetCategory } from '../../entities';
+import { BaseRepository } from '../baseRepository';
+export declare class AssetCategoriesRepository extends BaseRepository {
+    /**
+     * Get all asset categories
+     * @returns {Promise<AssetCategory[]>} The asset categories
+     */
+    getAssetCategories(forceUseReplica?: boolean): Promise<AssetCategory[]>;
+}

package/dist/repositories/assetCategories/index.js

@@ -1,17 +1,17 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { BaseRepository } from '../baseRepository';
-import { getAssetCategories } from './getAssetCategories';
-export class AssetCategoriesRepository extends BaseRepository {
-    /**
-     * Get all asset categories
-     * @returns {Promise<AssetCategory[]>} The asset categories
-     */
-    async getAssetCategories(forceUseReplica) {
-        this.logger.trace('AssetCategoriesRepository::getAssetCategories started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getAssetCategories(novaDataSource, forceUseReplica);
-        this.logger.trace(result, 'AssetCategoriesRepository::getAssetCategories result');
-        return result;
-    }
-}
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { getAssetCategories } from './getAssetCategories';
+export class AssetCategoriesRepository extends BaseRepository {
+    /**
+     * Get all asset categories
+     * @returns {Promise<AssetCategory[]>} The asset categories
+     */
+    async getAssetCategories(forceUseReplica) {
+        this.logger.trace('AssetCategoriesRepository::getAssetCategories started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await getAssetCategories(novaDataSource, forceUseReplica);
+        this.logger.trace(result, 'AssetCategoriesRepository::getAssetCategories result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/repositories/baseRepository.d.ts

@@ -1,21 +1,21 @@
-import { NovaDataSource, NovaDataSourceConfig } from '../novaDataSource';
-import { Logger } from '../types/logger';
-export declare class BaseRepository {
-    protected readonly novaDataSourceConfig: NovaDataSourceConfig;
-    protected readonly replicaNovaDataSourceConfig?: NovaDataSourceConfig;
-    protected readonly logger: Logger;
-    protected readonly useBeta: boolean;
-    constructor(config: NovaDataSourceConfig, logger: Logger, replicaConfig?: NovaDataSourceConfig, useBeta?: boolean);
-}
-interface BaseRepository2Options {
-    useBeta?: boolean;
-    dataSource: NovaDataSource;
-    logger?: Logger;
-}
-export declare class BaseRepository2 {
-    protected readonly useBeta: boolean;
-    protected readonly dataSource: NovaDataSource;
-    protected readonly logger: Logger;
-    constructor(options: BaseRepository2Options);
-}
-export {};
+import { NovaDataSource, NovaDataSourceConfig } from '../novaDataSource';
+import { Logger } from '../types/logger';
+export declare class BaseRepository {
+    protected readonly novaDataSourceConfig: NovaDataSourceConfig;
+    protected readonly replicaNovaDataSourceConfig?: NovaDataSourceConfig;
+    protected readonly logger: Logger;
+    protected readonly useBeta: boolean;
+    constructor(config: NovaDataSourceConfig, logger: Logger, replicaConfig?: NovaDataSourceConfig, useBeta?: boolean);
+}
+interface BaseRepository2Options {
+    useBeta?: boolean;
+    dataSource: NovaDataSource;
+    logger?: Logger;
+}
+export declare class BaseRepository2 {
+    protected readonly useBeta: boolean;
+    protected readonly dataSource: NovaDataSource;
+    protected readonly logger: Logger;
+    constructor(options: BaseRepository2Options);
+}
+export {};

package/dist/repositories/baseRepository.js

@@ -1,24 +1,24 @@
-import { ConsoleLogger } from '../utils/consoleLogger';
-export class BaseRepository {
-    novaDataSourceConfig;
-    replicaNovaDataSourceConfig;
-    logger;
-    useBeta;
-    constructor(config, logger, replicaConfig, useBeta = false) {
-        this.novaDataSourceConfig = config;
-        this.replicaNovaDataSourceConfig = replicaConfig;
-        this.logger = logger ?? new ConsoleLogger();
-        this.useBeta = useBeta;
-    }
-}
-export class BaseRepository2 {
-    useBeta;
-    dataSource;
-    logger;
-    constructor(options) {
-        this.useBeta = options.useBeta ?? false;
-        this.dataSource = options.dataSource;
-        this.logger = options.logger ?? new ConsoleLogger();
-    }
-}
+import { ConsoleLogger } from '../utils/consoleLogger';
+export class BaseRepository {
+    novaDataSourceConfig;
+    replicaNovaDataSourceConfig;
+    logger;
+    useBeta;
+    constructor(config, logger, replicaConfig, useBeta = false) {
+        this.novaDataSourceConfig = config;
+        this.replicaNovaDataSourceConfig = replicaConfig;
+        this.logger = logger ?? new ConsoleLogger();
+        this.useBeta = useBeta;
+    }
+}
+export class BaseRepository2 {
+    useBeta;
+    dataSource;
+    logger;
+    constructor(options) {
+        this.useBeta = options.useBeta ?? false;
+        this.dataSource = options.dataSource;
+        this.logger = options.logger ?? new ConsoleLogger();
+    }
+}
 //# sourceMappingURL=baseRepository.js.map

package/dist/repositories/billing/createBilling.d.ts

@@ -1,5 +1,5 @@
-import { Billing } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { CreateBillingParams } from '../../types/billing';
-import { Logger } from '../../types/logger';
-export declare const createBilling: (novaDataSource: NovaDataSource, params: CreateBillingParams, logger: Logger) => Promise<Billing>;
+import { Billing } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { CreateBillingParams } from '../../types/billing';
+import { Logger } from '../../types/logger';
+export declare const createBilling: (novaDataSource: NovaDataSource, params: CreateBillingParams, logger: Logger) => Promise<Billing>;