topaLE
/
ghostfolio
mirror of https://github.com/ghostfolio/ghostfolio
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Disable extended prisma client

feature/disable-extended-prisma-client
Thomas Kaul 5 days ago
parent
b2634db99f
commit
835bd6090e
1 changed files with 401 additions and 393 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 780
      apps/api/src/app/admin/admin.service.ts

780
apps/api/src/app/admin/admin.service.ts
View File

@ -1,7 +1,7 @@
import { OrderService } from '@ghostfolio/api/app/order/order.service'; import { OrderService } from '@ghostfolio/api/app/order/order.service';
import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscription.service'; import { SubscriptionService } from '@ghostfolio/api/app/subscription/subscription.service';
import { environment } from '@ghostfolio/api/environments/environment'; import { environment } from '@ghostfolio/api/environments/environment';
import { BenchmarkService } from '@ghostfolio/api/services/benchmark/benchmark.service'; // import { BenchmarkService } from '@ghostfolio/api/services/benchmark/benchmark.service';
import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service'; import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service'; import { DataProviderService } from '@ghostfolio/api/services/data-provider/data-provider.service';
import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service'; import { ExchangeRateDataService } from '@ghostfolio/api/services/exchange-rate-data/exchange-rate-data.service';
@ -15,7 +15,7 @@ import {
PROPERTY_IS_USER_SIGNUP_ENABLED PROPERTY_IS_USER_SIGNUP_ENABLED
} from '@ghostfolio/common/config'; } from '@ghostfolio/common/config';
import { import {
getAssetProfileIdentifier, // getAssetProfileIdentifier,
getCurrencyFromSymbol, getCurrencyFromSymbol,
isCurrency isCurrency
} from '@ghostfolio/common/helper'; } from '@ghostfolio/common/helper';
@ -23,38 +23,39 @@ import {
AdminData, AdminData,
AdminMarketData, AdminMarketData,
AdminMarketDataDetails, AdminMarketDataDetails,
AdminMarketDataItem, // AdminMarketDataItem,
AdminUsers, AdminUsers,
AssetProfileIdentifier, AssetProfileIdentifier,
EnhancedSymbolProfile, EnhancedSymbolProfile,
Filter Filter
} from '@ghostfolio/common/interfaces'; } from '@ghostfolio/common/interfaces';
import { Sector } from '@ghostfolio/common/interfaces/sector.interface'; // import { Sector } from '@ghostfolio/common/interfaces/sector.interface';
import { MarketDataPreset } from '@ghostfolio/common/types'; import { MarketDataPreset } from '@ghostfolio/common/types';
import { import {
BadRequestException, BadRequestException,
HttpException, HttpException,
Injectable, Injectable
Logger // Logger
} from '@nestjs/common'; } from '@nestjs/common';
import { import {
AssetClass, AssetClass,
AssetSubClass, AssetSubClass,
DataSource, DataSource,
Prisma, Prisma,
PrismaClient, // PrismaClient,
Property, Property,
SymbolProfile SymbolProfile
} from '@prisma/client'; } from '@prisma/client';
import { differenceInDays } from 'date-fns'; import { differenceInDays } from 'date-fns';
import { StatusCodes, getReasonPhrase } from 'http-status-codes'; import { StatusCodes, getReasonPhrase } from 'http-status-codes';
import { groupBy } from 'lodash';
// import { groupBy } from 'lodash';
@Injectable() @Injectable()
export class AdminService { export class AdminService {
public constructor( public constructor(
private readonly benchmarkService: BenchmarkService, // private readonly benchmarkService: BenchmarkService,
private readonly configurationService: ConfigurationService, private readonly configurationService: ConfigurationService,
private readonly dataProviderService: DataProviderService, private readonly dataProviderService: DataProviderService,
private readonly exchangeRateDataService: ExchangeRateDataService, private readonly exchangeRateDataService: ExchangeRateDataService,
@ -151,13 +152,14 @@ export class AdminService {
}; };
} }
public async getMarketData({ public async getMarketData(
filters, {
presetId, // filters,
sortColumn, // presetId,
sortDirection, // sortColumn,
skip, // sortDirection,
take = Number.MAX_SAFE_INTEGER // skip,
// take = Number.MAX_SAFE_INTEGER
}: { }: {
filters?: Filter[]; filters?: Filter[];
presetId?: MarketDataPreset; presetId?: MarketDataPreset;
@ -165,247 +167,253 @@ export class AdminService {
sortColumn?: string; sortColumn?: string;
sortDirection?: Prisma.SortOrder; sortDirection?: Prisma.SortOrder;
take?: number; take?: number;
}): Promise<AdminMarketData> {
let orderBy: Prisma.Enumerable<Prisma.SymbolProfileOrderByWithRelationInput> =
[{ symbol: 'asc' }];
const where: Prisma.SymbolProfileWhereInput = {};
if (presetId === 'BENCHMARKS') {
const benchmarkAssetProfiles =
await this.benchmarkService.getBenchmarkAssetProfiles();
where.id = {
in: benchmarkAssetProfiles.map(({ id }) => {
return id;
})
};
} else if (presetId === 'CURRENCIES') {
return this.getMarketDataForCurrencies();
} else if (
presetId === 'ETF_WITHOUT_COUNTRIES' ||
presetId === 'ETF_WITHOUT_SECTORS'
) {
filters = [{ id: 'ETF', type: 'ASSET_SUB_CLASS' }];
}
const searchQuery = filters.find(({ type }) => {
return type === 'SEARCH_QUERY';
})?.id;
const { ASSET_SUB_CLASS: filtersByAssetSubClass } = groupBy(
filters,
({ type }) => {
return type;
}
);
const marketDataItems = await this.prismaService.marketData.groupBy({
_count: true,
by: ['dataSource', 'symbol']
});
if (filtersByAssetSubClass) {
where.assetSubClass = AssetSubClass[filtersByAssetSubClass[0].id];
}
if (searchQuery) {
where.OR = [
{ id: { mode: 'insensitive', startsWith: searchQuery } },
{ isin: { mode: 'insensitive', startsWith: searchQuery } },
{ name: { mode: 'insensitive', startsWith: searchQuery } },
{ symbol: { mode: 'insensitive', startsWith: searchQuery } }
];
}
if (sortColumn) {
orderBy = [{ [sortColumn]: sortDirection }];
if (sortColumn === 'activitiesCount') {
orderBy = {
Order: {
_count: sortDirection
}
};
}
}
const extendedPrismaClient = this.getExtendedPrismaClient();
try {
const symbolProfileResult = await Promise.all([
extendedPrismaClient.symbolProfile.findMany({
orderBy,
skip,
take,
where,
select: {
_count: {
select: { Order: true }
},
assetClass: true,
assetSubClass: true,
comment: true,
countries: true,
currency: true,
dataSource: true,
id: true,
isActive: true,
isUsedByUsersWithSubscription: true,
name: true,
Order: {
orderBy: [{ date: 'asc' }],
select: { date: true },
take: 1
},
scraperConfiguration: true,
sectors: true,
symbol: true,
SymbolProfileOverrides: true
}
}),
this.prismaService.symbolProfile.count({ where })
]);
const assetProfiles = symbolProfileResult[0];
let count = symbolProfileResult[1];
const lastMarketPrices = await this.prismaService.marketData.findMany({
distinct: ['dataSource', 'symbol'],
orderBy: { date: 'desc' },
select: {
dataSource: true,
marketPrice: true,
symbol: true
},
where: {
dataSource: {
in: assetProfiles.map(({ dataSource }) => {
return dataSource;
})
},
symbol: {
in: assetProfiles.map(({ symbol }) => {
return symbol;
})
}
} }
): Promise<AdminMarketData> {
return Promise.resolve({
count: 0,
marketData: []
}); });
const lastMarketPriceMap = new Map<string, number>(); // let orderBy: Prisma.Enumerable<Prisma.SymbolProfileOrderByWithRelationInput> =
// [{ symbol: 'asc' }];
for (const { dataSource, marketPrice, symbol } of lastMarketPrices) { // const where: Prisma.SymbolProfileWhereInput = {};
lastMarketPriceMap.set(
getAssetProfileIdentifier({ dataSource, symbol }), // if (presetId === 'BENCHMARKS') {
marketPrice // const benchmarkAssetProfiles =
); // await this.benchmarkService.getBenchmarkAssetProfiles();
}
// where.id = {
let marketData: AdminMarketDataItem[] = await Promise.all( // in: benchmarkAssetProfiles.map(({ id }) => {
assetProfiles.map( // return id;
async ({ // })
_count, // };
assetClass, // } else if (presetId === 'CURRENCIES') {
assetSubClass, // return this.getMarketDataForCurrencies();
comment, // } else if (
countries, // presetId === 'ETF_WITHOUT_COUNTRIES' ||
currency, // presetId === 'ETF_WITHOUT_SECTORS'
dataSource, // ) {
id, // filters = [{ id: 'ETF', type: 'ASSET_SUB_CLASS' }];
isActive, // }
isUsedByUsersWithSubscription,
name, // const searchQuery = filters.find(({ type }) => {
Order, // return type === 'SEARCH_QUERY';
sectors, // })?.id;
symbol,
SymbolProfileOverrides // const { ASSET_SUB_CLASS: filtersByAssetSubClass } = groupBy(
}) => { // filters,
let countriesCount = countries ? Object.keys(countries).length : 0; // ({ type }) => {
// return type;
const lastMarketPrice = lastMarketPriceMap.get( // }
getAssetProfileIdentifier({ dataSource, symbol }) // );
);
// const marketDataItems = await this.prismaService.marketData.groupBy({
const marketDataItemCount = // _count: true,
marketDataItems.find((marketDataItem) => { // by: ['dataSource', 'symbol']
return ( // });
marketDataItem.dataSource === dataSource &&
marketDataItem.symbol === symbol // if (filtersByAssetSubClass) {
); // where.assetSubClass = AssetSubClass[filtersByAssetSubClass[0].id];
})?._count ?? 0; // }
let sectorsCount = sectors ? Object.keys(sectors).length : 0; // if (searchQuery) {
// where.OR = [
if (SymbolProfileOverrides) { // { id: { mode: 'insensitive', startsWith: searchQuery } },
assetClass = SymbolProfileOverrides.assetClass ?? assetClass; // { isin: { mode: 'insensitive', startsWith: searchQuery } },
assetSubClass = // { name: { mode: 'insensitive', startsWith: searchQuery } },
SymbolProfileOverrides.assetSubClass ?? assetSubClass; // { symbol: { mode: 'insensitive', startsWith: searchQuery } }
// ];
if ( // }
(
SymbolProfileOverrides.countries as unknown as Prisma.JsonArray // if (sortColumn) {
)?.length > 0 // orderBy = [{ [sortColumn]: sortDirection }];
) {
countriesCount = ( // if (sortColumn === 'activitiesCount') {
SymbolProfileOverrides.countries as unknown as Prisma.JsonArray // orderBy = {
).length; // Order: {
} // _count: sortDirection
// }
name = SymbolProfileOverrides.name ?? name; // };
// }
if ( // }
(SymbolProfileOverrides.sectors as unknown as Sector[])
?.length > 0 // const extendedPrismaClient = this.getExtendedPrismaClient();
) {
sectorsCount = ( // try {
SymbolProfileOverrides.sectors as unknown as Prisma.JsonArray // const symbolProfileResult = await Promise.all([
).length; // extendedPrismaClient.symbolProfile.findMany({
} // orderBy,
} // skip,
// take,
return { // where,
assetClass, // select: {
assetSubClass, // _count: {
comment, // select: { Order: true }
currency, // },
countriesCount, // assetClass: true,
dataSource, // assetSubClass: true,
id, // comment: true,
isActive, // countries: true,
lastMarketPrice, // currency: true,
name, // dataSource: true,
symbol, // id: true,
marketDataItemCount, // isActive: true,
sectorsCount, // isUsedByUsersWithSubscription: true,
activitiesCount: _count.Order, // name: true,
date: Order?.[0]?.date, // Order: {
isUsedByUsersWithSubscription: await isUsedByUsersWithSubscription // orderBy: [{ date: 'asc' }],
}; // select: { date: true },
} // take: 1
) // },
); // scraperConfiguration: true,
// sectors: true,
if (presetId) { // symbol: true,
if (presetId === 'ETF_WITHOUT_COUNTRIES') { // SymbolProfileOverrides: true
marketData = marketData.filter(({ countriesCount }) => { // }
return countriesCount === 0; // }),
}); // this.prismaService.symbolProfile.count({ where })
} else if (presetId === 'ETF_WITHOUT_SECTORS') { // ]);
marketData = marketData.filter(({ sectorsCount }) => { // const assetProfiles = symbolProfileResult[0];
return sectorsCount === 0; // let count = symbolProfileResult[1];
});
} // const lastMarketPrices = await this.prismaService.marketData.findMany({
// distinct: ['dataSource', 'symbol'],
count = marketData.length; // orderBy: { date: 'desc' },
} // select: {
// dataSource: true,
return { // marketPrice: true,
count, // symbol: true
marketData // },
}; // where: {
} finally { // dataSource: {
await extendedPrismaClient.$disconnect(); // in: assetProfiles.map(({ dataSource }) => {
// return dataSource;
Logger.debug('Disconnect extended prisma client', 'AdminService'); // })
} // },
// symbol: {
// in: assetProfiles.map(({ symbol }) => {
// return symbol;
// })
// }
// }
// });
// const lastMarketPriceMap = new Map<string, number>();
// for (const { dataSource, marketPrice, symbol } of lastMarketPrices) {
// lastMarketPriceMap.set(
// getAssetProfileIdentifier({ dataSource, symbol }),
// marketPrice
// );
// }
// let marketData: AdminMarketDataItem[] = await Promise.all(
// assetProfiles.map(
// async ({
// _count,
// assetClass,
// assetSubClass,
// comment,
// countries,
// currency,
// dataSource,
// id,
// isActive,
// isUsedByUsersWithSubscription,
// name,
// Order,
// sectors,
// symbol,
// SymbolProfileOverrides
// }) => {
// let countriesCount = countries ? Object.keys(countries).length : 0;
// const lastMarketPrice = lastMarketPriceMap.get(
// getAssetProfileIdentifier({ dataSource, symbol })
// );
// const marketDataItemCount =
// marketDataItems.find((marketDataItem) => {
// return (
// marketDataItem.dataSource === dataSource &&
// marketDataItem.symbol === symbol
// );
// })?._count ?? 0;
// let sectorsCount = sectors ? Object.keys(sectors).length : 0;
// if (SymbolProfileOverrides) {
// assetClass = SymbolProfileOverrides.assetClass ?? assetClass;
// assetSubClass =
// SymbolProfileOverrides.assetSubClass ?? assetSubClass;
// if (
// (
// SymbolProfileOverrides.countries as unknown as Prisma.JsonArray
// )?.length > 0
// ) {
// countriesCount = (
// SymbolProfileOverrides.countries as unknown as Prisma.JsonArray
// ).length;
// }
// name = SymbolProfileOverrides.name ?? name;
// if (
// (SymbolProfileOverrides.sectors as unknown as Sector[])
// ?.length > 0
// ) {
// sectorsCount = (
// SymbolProfileOverrides.sectors as unknown as Prisma.JsonArray
// ).length;
// }
// }
// return {
// assetClass,
// assetSubClass,
// comment,
// currency,
// countriesCount,
// dataSource,
// id,
// isActive,
// lastMarketPrice,
// name,
// symbol,
// marketDataItemCount,
// sectorsCount,
// activitiesCount: _count.Order,
// date: Order?.[0]?.date,
// isUsedByUsersWithSubscription: await isUsedByUsersWithSubscription
// };
// }
// )
// );
// if (presetId) {
// if (presetId === 'ETF_WITHOUT_COUNTRIES') {
// marketData = marketData.filter(({ countriesCount }) => {
// return countriesCount === 0;
// });
// } else if (presetId === 'ETF_WITHOUT_SECTORS') {
// marketData = marketData.filter(({ sectorsCount }) => {
// return sectorsCount === 0;
// });
// }
// count = marketData.length;
// }
// return {
// count,
// marketData
// };
// } finally {
// await extendedPrismaClient.$disconnect();
// Logger.debug('Disconnect extended prisma client', 'AdminService');
// }
} }
public async getMarketDataBySymbol({ public async getMarketDataBySymbol({
@ -629,138 +637,138 @@ export class AdminService {
}); });
} }
private getExtendedPrismaClient() { // private getExtendedPrismaClient() {
Logger.debug('Connect extended prisma client', 'AdminService'); // Logger.debug('Connect extended prisma client', 'AdminService');
const symbolProfileExtension = Prisma.defineExtension((client) => { // const symbolProfileExtension = Prisma.defineExtension((client) => {
return client.$extends({ // return client.$extends({
result: { // result: {
symbolProfile: { // symbolProfile: {
isUsedByUsersWithSubscription: { // isUsedByUsersWithSubscription: {
compute: async ({ id }) => { // compute: async ({ id }) => {
const { _count } = // const { _count } =
await this.prismaService.symbolProfile.findUnique({ // await this.prismaService.symbolProfile.findUnique({
select: { // select: {
_count: { // _count: {
select: { // select: {
Order: { // Order: {
where: { // where: {
User: { // User: {
Subscription: { // Subscription: {
some: { // some: {
expiresAt: { // expiresAt: {
gt: new Date() // gt: new Date()
} // }
} // }
} // }
} // }
} // }
} // }
} // }
} // }
}, // },
where: { // where: {
id // id
} // }
}); // });
return _count.Order > 0; // return _count.Order > 0;
} // }
} // }
} // }
} // }
}); // });
}); // });
return new PrismaClient().$extends(symbolProfileExtension); // return new PrismaClient().$extends(symbolProfileExtension);
} // }
private async getMarketDataForCurrencies(): Promise<AdminMarketData> { // private async getMarketDataForCurrencies(): Promise<AdminMarketData> {
const currencyPairs = this.exchangeRateDataService.getCurrencyPairs(); // const currencyPairs = this.exchangeRateDataService.getCurrencyPairs();
const [lastMarketPrices, marketDataItems] = await Promise.all([ // const [lastMarketPrices, marketDataItems] = await Promise.all([
this.prismaService.marketData.findMany({ // this.prismaService.marketData.findMany({
distinct: ['dataSource', 'symbol'], // distinct: ['dataSource', 'symbol'],
orderBy: { date: 'desc' }, // orderBy: { date: 'desc' },
select: { // select: {
dataSource: true, // dataSource: true,
marketPrice: true, // marketPrice: true,
symbol: true // symbol: true
}, // },
where: { // where: {
dataSource: { // dataSource: {
in: currencyPairs.map(({ dataSource }) => { // in: currencyPairs.map(({ dataSource }) => {
return dataSource; // return dataSource;
}) // })
}, // },
symbol: { // symbol: {
in: currencyPairs.map(({ symbol }) => { // in: currencyPairs.map(({ symbol }) => {
return symbol; // return symbol;
}) // })
} // }
} // }
}), // }),
this.prismaService.marketData.groupBy({ // this.prismaService.marketData.groupBy({
_count: true, // _count: true,
by: ['dataSource', 'symbol'] // by: ['dataSource', 'symbol']
}) // })
]); // ]);
const lastMarketPriceMap = new Map<string, number>(); // const lastMarketPriceMap = new Map<string, number>();
for (const { dataSource, marketPrice, symbol } of lastMarketPrices) { // for (const { dataSource, marketPrice, symbol } of lastMarketPrices) {
lastMarketPriceMap.set( // lastMarketPriceMap.set(
getAssetProfileIdentifier({ dataSource, symbol }), // getAssetProfileIdentifier({ dataSource, symbol }),
marketPrice // marketPrice
); // );
} // }
const marketDataPromise: Promise<AdminMarketDataItem>[] = currencyPairs.map( // const marketDataPromise: Promise<AdminMarketDataItem>[] = currencyPairs.map(
async ({ dataSource, symbol }) => { // async ({ dataSource, symbol }) => {
let activitiesCount: EnhancedSymbolProfile['activitiesCount'] = 0; // let activitiesCount: EnhancedSymbolProfile['activitiesCount'] = 0;
let currency: EnhancedSymbolProfile['currency'] = '-'; // let currency: EnhancedSymbolProfile['currency'] = '-';
let dateOfFirstActivity: EnhancedSymbolProfile['dateOfFirstActivity']; // let dateOfFirstActivity: EnhancedSymbolProfile['dateOfFirstActivity'];
if (isCurrency(getCurrencyFromSymbol(symbol))) { // if (isCurrency(getCurrencyFromSymbol(symbol))) {
currency = getCurrencyFromSymbol(symbol); // currency = getCurrencyFromSymbol(symbol);
({ activitiesCount, dateOfFirstActivity } = // ({ activitiesCount, dateOfFirstActivity } =
await this.orderService.getStatisticsByCurrency(currency)); // await this.orderService.getStatisticsByCurrency(currency));
} // }
const lastMarketPrice = lastMarketPriceMap.get( // const lastMarketPrice = lastMarketPriceMap.get(
getAssetProfileIdentifier({ dataSource, symbol }) // getAssetProfileIdentifier({ dataSource, symbol })
); // );
const marketDataItemCount = // const marketDataItemCount =
marketDataItems.find((marketDataItem) => { // marketDataItems.find((marketDataItem) => {
return ( // return (
marketDataItem.dataSource === dataSource && // marketDataItem.dataSource === dataSource &&
marketDataItem.symbol === symbol // marketDataItem.symbol === symbol
); // );
})?._count ?? 0; // })?._count ?? 0;
return { // return {
activitiesCount, // activitiesCount,
currency, // currency,
dataSource, // dataSource,
lastMarketPrice, // lastMarketPrice,
marketDataItemCount, // marketDataItemCount,
symbol, // symbol,
assetClass: AssetClass.LIQUIDITY, // assetClass: AssetClass.LIQUIDITY,
assetSubClass: AssetSubClass.CASH, // assetSubClass: AssetSubClass.CASH,
countriesCount: 0, // countriesCount: 0,
date: dateOfFirstActivity, // date: dateOfFirstActivity,
id: undefined, // id: undefined,
isActive: true, // isActive: true,
name: symbol, // name: symbol,
sectorsCount: 0 // sectorsCount: 0
}; // };
} // }
); // );
const marketData = await Promise.all(marketDataPromise); // const marketData = await Promise.all(marketDataPromise);
return { marketData, count: marketData.length }; // return { marketData, count: marketData.length };
} // }
private async getUsersWithAnalytics({ private async getUsersWithAnalytics({
skip, skip,

Write Preview
Loading…
Cancel
Save