#138 Services & Clients return List<R> instead of R[]

build.gradle

@@ -41,6 +41,7 @@ dependencies {
     implementation("org.apache.commons:commons-lang3:${apacheCommonsVersion}")
     implementation("com.diffplug.spotless:spotless-plugin-gradle:${spotlessVersion}")
 
+    testImplementation("org.assertj:assertj-core:${assertJVersion}")
     testImplementation("org.mockito:mockito-core:${mockitoCoreVersion}")
     testImplementation("org.mockito:mockito-junit-jupiter:${mockitoJunitVersion}")
     testImplementation(platform("org.junit:junit-bom:${junitVersion}"))

gradle.properties

@@ -1,4 +1,5 @@
 projectVersion=0.3.0
+assertJVersion=3.27.4
 junitVersion=5.10.0
 mockitoJunitVersion=2.17.0
 mockitoCoreVersion=5.18.0

src/main/java/dev/sorn/fmp4j/clients/FmpBulkClient.java

@@ -17,14 +17,15 @@
 import dev.sorn.fmp4j.types.FmpPart;
 import dev.sorn.fmp4j.types.FmpPeriod;
 import dev.sorn.fmp4j.types.FmpYear;
+import java.util.List;
 
 public class FmpBulkClient {
 
     // Alphabetical order
-    protected final FmpService<FmpCompanies[]> fmpBulkCompaniesService;
-    protected final FmpService<FmpBalanceSheetStatement[]> fmpBulkBalanceSheetService;
-    protected final FmpService<FmpCashFlowStatement[]> fmpBulkCashFlowService;
-    protected final FmpService<FmpCashFlowStatementGrowth[]> fmpBulkCashFlowStatementGrowthService;
+    protected final FmpService<FmpCompanies> fmpBulkCompaniesService;
+    protected final FmpService<FmpBalanceSheetStatement> fmpBulkBalanceSheetService;
+    protected final FmpService<FmpCashFlowStatement> fmpBulkCashFlowService;
+    protected final FmpService<FmpCashFlowStatementGrowth> fmpBulkCashFlowStatementGrowthService;
 
     public FmpBulkClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpBulkCompaniesService = new FmpBulkCompaniesService(fmpConfig, fmpHttpClient);
@@ -34,24 +35,24 @@
                 new FmpBulkCashFlowStatementGrowthService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpCompanies[] companies(FmpPart part) {
+    public synchronized List<FmpCompanies> companies(FmpPart part) {
         fmpBulkCompaniesService.param("part", part);
         return fmpBulkCompaniesService.download();
     }
 
-    public synchronized FmpBalanceSheetStatement[] balanceSheetStatements(FmpYear year, FmpPeriod period) {
+    public synchronized List<FmpBalanceSheetStatement> balanceSheetStatements(FmpYear year, FmpPeriod period) {
         fmpBulkBalanceSheetService.param(PARAM_YEAR, year);
         fmpBulkBalanceSheetService.param(PARAM_PERIOD, period);
         return fmpBulkBalanceSheetService.download();
     }
 
-    public synchronized FmpCashFlowStatement[] cashFlowStatements(FmpYear year, FmpPeriod period) {
+    public synchronized List<FmpCashFlowStatement> cashFlowStatements(FmpYear year, FmpPeriod period) {
         fmpBulkCashFlowService.param(PARAM_YEAR, year);
         fmpBulkCashFlowService.param(PARAM_PERIOD, period);
         return fmpBulkCashFlowService.download();
     }
 
-    public synchronized FmpCashFlowStatementGrowth[] cashFlowStatementGrowth(FmpYear year, FmpPeriod period) {
+    public synchronized List<FmpCashFlowStatementGrowth> cashFlowStatementGrowth(FmpYear year, FmpPeriod period) {
         fmpBulkCashFlowStatementGrowthService.param(PARAM_YEAR, year);
         fmpBulkCashFlowStatementGrowthService.param(PARAM_PERIOD, period);
         return fmpBulkCashFlowStatementGrowthService.download();

src/main/java/dev/sorn/fmp4j/clients/FmpCalendarClient.java

@@ -27,20 +27,21 @@
 import dev.sorn.fmp4j.services.FmpSplitsCalendarService;
 import dev.sorn.fmp4j.types.FmpSymbol;
 import java.time.LocalDate;
+import java.util.List;
 import java.util.Optional;
 
 public class FmpCalendarClient {
 
     // Alphabetical order
-    protected final FmpService<FmpDividend[]> fmpDividendService;
-    protected final FmpService<FmpDividendsCalendar[]> fmpDividendsCalendarService;
-    protected final FmpService<FmpEarning[]> fmpEarningsService;
-    protected final FmpService<FmpEarningsCalendar[]> fmpEarningsCalendarService;
-    protected final FmpService<FmpIposCalendar[]> fmpIposCalendarService;
-    protected final FmpService<FmpIposDisclosure[]> fmpIposDisclosureService;
-    protected final FmpService<FmpIposProspectus[]> fmpIposProspectusService;
-    protected final FmpService<FmpSplit[]> fmpSplitService;
-    protected final FmpService<FmpSplitsCalendar[]> fmpSplitsCalendarService;
+    protected final FmpService<FmpDividend> fmpDividendService;
+    protected final FmpService<FmpDividendsCalendar> fmpDividendsCalendarService;
+    protected final FmpService<FmpEarning> fmpEarningsService;
+    protected final FmpService<FmpEarningsCalendar> fmpEarningsCalendarService;
+    protected final FmpService<FmpIposCalendar> fmpIposCalendarService;
+    protected final FmpService<FmpIposDisclosure> fmpIposDisclosureService;
+    protected final FmpService<FmpIposProspectus> fmpIposProspectusService;
+    protected final FmpService<FmpSplit> fmpSplitService;
+    protected final FmpService<FmpSplitsCalendar> fmpSplitsCalendarService;
 
     public FmpCalendarClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpDividendService = new FmpDividendService(fmpConfig, fmpHttpClient);
@@ -54,47 +55,47 @@
         this.fmpSplitsCalendarService = new FmpSplitsCalendarService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpDividendsCalendar[] dividends() {
+    public synchronized List<FmpDividendsCalendar> dividends() {
         return fmpDividendsCalendarService.download();
     }
 
-    public synchronized FmpDividend[] dividends(FmpSymbol symbol) {
+    public synchronized List<FmpDividend> dividends(FmpSymbol symbol) {
         fmpDividendService.param(PARAM_SYMBOL, symbol);
         return fmpDividendService.download();
     }
 
-    public synchronized FmpEarningsCalendar[] earnings() {
+    public synchronized List<FmpEarningsCalendar> earnings() {
         return fmpEarningsCalendarService.download();
     }
 
-    public synchronized FmpEarning[] earnings(FmpSymbol symbol) {
+    public synchronized List<FmpEarning> earnings(FmpSymbol symbol) {
         fmpEarningsService.param(PARAM_SYMBOL, symbol);
         return fmpEarningsService.download();
     }
 
-    public synchronized FmpIposCalendar[] ipos(Optional<LocalDate> from, Optional<LocalDate> to) {
+    public synchronized List<FmpIposCalendar> ipos(Optional<LocalDate> from, Optional<LocalDate> to) {
         fmpIposCalendarService.param(PARAM_FROM, from);
         fmpIposCalendarService.param(PARAM_TO, to);
         return fmpIposCalendarService.download();
     }
 
-    public synchronized FmpIposDisclosure[] disclosures(Optional<LocalDate> from, Optional<LocalDate> to) {
+    public synchronized List<FmpIposDisclosure> disclosures(Optional<LocalDate> from, Optional<LocalDate> to) {
         fmpIposDisclosureService.param(PARAM_FROM, from);
         fmpIposDisclosureService.param(PARAM_TO, to);
         return fmpIposDisclosureService.download();
     }
 
-    public synchronized FmpIposProspectus[] prospectus(Optional<LocalDate> from, Optional<LocalDate> to) {
+    public synchronized List<FmpIposProspectus> prospectus(Optional<LocalDate> from, Optional<LocalDate> to) {
         fmpIposProspectusService.param(PARAM_FROM, from);
         fmpIposProspectusService.param(PARAM_TO, to);
         return fmpIposProspectusService.download();
     }
 
-    public synchronized FmpSplitsCalendar[] splits() {
+    public synchronized List<FmpSplitsCalendar> splits() {
         return fmpSplitsCalendarService.download();
     }
 
-    public synchronized FmpSplit[] splits(FmpSymbol symbol) {
+    public synchronized List<FmpSplit> splits(FmpSymbol symbol) {
         fmpSplitService.param(PARAM_SYMBOL, symbol);
         return fmpSplitService.download();
     }

src/main/java/dev/sorn/fmp4j/clients/FmpChartClient.java

@@ -22,18 +22,19 @@
 import dev.sorn.fmp4j.types.FmpInterval;
 import dev.sorn.fmp4j.types.FmpSymbol;
 import java.time.LocalDate;
+import java.util.List;
 import java.util.Optional;
 
 public class FmpChartClient {
 
-    protected final FmpService<FmpHistoricalPriceEodLight[]> fmpHistoricalPriceEodLightService;
-    protected final FmpService<FmpHistoricalPriceEodFull[]> fmpHistoricalPriceEodFullService;
-    protected final FmpService<FmpHistoricalChart[]> fmpHistoricalChartService1MinService;
-    protected final FmpService<FmpHistoricalChart[]> fmpHistoricalChartService5MinService;
-    protected final FmpService<FmpHistoricalChart[]> fmpHistoricalChartService15MinService;
-    protected final FmpService<FmpHistoricalChart[]> fmpHistoricalChartService30MinService;
-    protected final FmpService<FmpHistoricalChart[]> fmpHistoricalChartService1HourService;
-    protected final FmpService<FmpHistoricalChart[]> fmpHistoricalChartService4HourService;
+    protected final FmpService<FmpHistoricalPriceEodLight> fmpHistoricalPriceEodLightService;
+    protected final FmpService<FmpHistoricalPriceEodFull> fmpHistoricalPriceEodFullService;
+    protected final FmpService<FmpHistoricalChart> fmpHistoricalChartService1MinService;
+    protected final FmpService<FmpHistoricalChart> fmpHistoricalChartService5MinService;
+    protected final FmpService<FmpHistoricalChart> fmpHistoricalChartService15MinService;
+    protected final FmpService<FmpHistoricalChart> fmpHistoricalChartService30MinService;
+    protected final FmpService<FmpHistoricalChart> fmpHistoricalChartService1HourService;
+    protected final FmpService<FmpHistoricalChart> fmpHistoricalChartService4HourService;
 
     public FmpChartClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpHistoricalPriceEodLightService = new FmpHistoricalPriceEodLightService(fmpConfig, fmpHttpClient);
@@ -49,23 +50,23 @@
         this.fmpHistoricalChartService4HourService = new FmpHistoricalChartService(fmpConfig, fmpHttpClient, FOUR_HOUR);
     }
 
-    public synchronized FmpHistoricalPriceEodLight[] historicalPriceEodLight(
+    public synchronized List<FmpHistoricalPriceEodLight> historicalPriceEodLight(
             FmpSymbol symbol, Optional<LocalDate> from, Optional<LocalDate> to) {
         fmpHistoricalPriceEodLightService.param(PARAM_SYMBOL, symbol);
         from.ifPresent(date -> fmpHistoricalPriceEodLightService.param(PARAM_FROM, date));
         to.ifPresent(date -> fmpHistoricalPriceEodLightService.param(PARAM_TO, date));
         return fmpHistoricalPriceEodLightService.download();
     }
 
-    public synchronized FmpHistoricalPriceEodFull[] historicalPriceEodFull(
+    public synchronized List<FmpHistoricalPriceEodFull> historicalPriceEodFull(
             FmpSymbol symbol, Optional<LocalDate> from, Optional<LocalDate> to) {
         fmpHistoricalPriceEodFullService.param(PARAM_SYMBOL, symbol);
         from.ifPresent(date -> fmpHistoricalPriceEodFullService.param(PARAM_FROM, date));
         to.ifPresent(date -> fmpHistoricalPriceEodFullService.param(PARAM_TO, date));
         return fmpHistoricalPriceEodFullService.download();
     }
 
-    public synchronized FmpHistoricalChart[] historical(
+    public synchronized List<FmpHistoricalChart> historical(
             FmpSymbol symbol, FmpInterval interval, Optional<LocalDate> from, Optional<LocalDate> to) {
         return switch (interval) {
             case ONE_MINUTE -> {

src/main/java/dev/sorn/fmp4j/clients/FmpCompanyClient.java

@@ -8,17 +8,18 @@
 import dev.sorn.fmp4j.services.FmpCompanyService;
 import dev.sorn.fmp4j.services.FmpService;
 import dev.sorn.fmp4j.types.FmpSymbol;
+import java.util.List;
 
 public class FmpCompanyClient {
 
     // Alphabetical order
-    protected final FmpService<FmpCompany[]> fmpCompanyService;
+    protected final FmpService<FmpCompany> fmpCompanyService;
 
     public FmpCompanyClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpCompanyService = new FmpCompanyService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpCompany[] bySymbol(FmpSymbol symbol) {
+    public synchronized List<FmpCompany> bySymbol(FmpSymbol symbol) {
         fmpCompanyService.param(PARAM_SYMBOL, symbol);
         return fmpCompanyService.download();
     }

src/main/java/dev/sorn/fmp4j/clients/FmpDirectoryClient.java

@@ -7,23 +7,24 @@
 import dev.sorn.fmp4j.services.FmpEtfListService;
 import dev.sorn.fmp4j.services.FmpService;
 import dev.sorn.fmp4j.services.FmpStockListService;
+import java.util.List;
 
 public class FmpDirectoryClient {
 
     // Alphabetical order
-    protected final FmpService<FmpEtf[]> fmpEtfListService;
-    protected final FmpService<FmpStock[]> fmpStockListService;
+    protected final FmpService<FmpEtf> fmpEtfListService;
+    protected final FmpService<FmpStock> fmpStockListService;
 
     public FmpDirectoryClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpEtfListService = new FmpEtfListService(fmpConfig, fmpHttpClient);
         this.fmpStockListService = new FmpStockListService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpEtf[] etfs() {
+    public synchronized List<FmpEtf> etfs() {
         return fmpEtfListService.download();
     }
 
-    public synchronized FmpStock[] stocks() {
+    public synchronized List<FmpStock> stocks() {
         return fmpStockListService.download();
     }
 }

src/main/java/dev/sorn/fmp4j/clients/FmpEarningsClient.java

@@ -24,15 +24,16 @@
 import dev.sorn.fmp4j.types.FmpQuarter;
 import dev.sorn.fmp4j.types.FmpSymbol;
 import dev.sorn.fmp4j.types.FmpYear;
+import java.util.List;
 import java.util.Optional;
 
 public class FmpEarningsClient {
 
     // Alphabetical order
-    protected final FmpService<FmpEarningsCallTranscript[]> fmpEarningsCallTranscriptService;
-    protected final FmpService<FmpEarningsCallTranscriptDate[]> fmpEarningsCallTranscriptDatesService;
-    protected final FmpService<FmpEarningsCallTranscriptLatest[]> fmpEarningsCallTranscriptLatestService;
-    protected final FmpService<FmpEarningsCallTranscriptList[]> fmpEarningsCallTranscriptListService;
+    protected final FmpService<FmpEarningsCallTranscript> fmpEarningsCallTranscriptService;
+    protected final FmpService<FmpEarningsCallTranscriptDate> fmpEarningsCallTranscriptDatesService;
+    protected final FmpService<FmpEarningsCallTranscriptLatest> fmpEarningsCallTranscriptLatestService;
+    protected final FmpService<FmpEarningsCallTranscriptList> fmpEarningsCallTranscriptListService;
 
     public FmpEarningsClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpEarningsCallTranscriptService = new FmpEarningsCallTranscriptService(fmpConfig, fmpHttpClient);
@@ -43,7 +44,7 @@
         this.fmpEarningsCallTranscriptListService = new FmpEarningsCallTranscriptListService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpEarningsCallTranscript[] transcripts(
+    public synchronized List<FmpEarningsCallTranscript> transcripts(
             FmpSymbol symbol, FmpYear year, FmpQuarter quarter, Optional<FmpLimit> limit) {
         fmpEarningsCallTranscriptService.param(PARAM_SYMBOL, symbol);
         fmpEarningsCallTranscriptService.param(PARAM_YEAR, year);
@@ -52,18 +53,18 @@
         return fmpEarningsCallTranscriptService.download();
     }
 
-    public synchronized FmpEarningsCallTranscriptDate[] dates(FmpSymbol symbol) {
+    public synchronized List<FmpEarningsCallTranscriptDate> dates(FmpSymbol symbol) {
         fmpEarningsCallTranscriptDatesService.param(PARAM_SYMBOL, symbol);
         return fmpEarningsCallTranscriptDatesService.download();
     }
 
-    public synchronized FmpEarningsCallTranscriptLatest[] latest(Optional<FmpLimit> limit, Optional<FmpPage> page) {
+    public synchronized List<FmpEarningsCallTranscriptLatest> latest(Optional<FmpLimit> limit, Optional<FmpPage> page) {
         fmpEarningsCallTranscriptLatestService.param(PARAM_LIMIT, limit.orElse(limit(100)));
         fmpEarningsCallTranscriptLatestService.param(PARAM_PAGE, page.orElse(page(0)));
         return fmpEarningsCallTranscriptLatestService.download();
     }
 
-    public synchronized FmpEarningsCallTranscriptList[] list() {
+    public synchronized List<FmpEarningsCallTranscriptList> list() {
         return fmpEarningsCallTranscriptListService.download();
     }
 }

src/main/java/dev/sorn/fmp4j/clients/FmpEconomicsClient.java

@@ -9,15 +9,16 @@
 import dev.sorn.fmp4j.services.FmpService;
 import dev.sorn.fmp4j.services.FmpTreasuryRatesService;
 import java.time.LocalDate;
+import java.util.List;
 
 public class FmpEconomicsClient {
-    protected final FmpService<FmpTreasuryRate[]> fmpTreasuryRatesService;
+    protected final FmpService<FmpTreasuryRate> fmpTreasuryRatesService;
 
     public FmpEconomicsClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.fmpTreasuryRatesService = new FmpTreasuryRatesService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpTreasuryRate[] treasuryRates(LocalDate from, LocalDate to) {
+    public synchronized List<FmpTreasuryRate> treasuryRates(LocalDate from, LocalDate to) {
         fmpTreasuryRatesService.param(PARAM_FROM, from);
         fmpTreasuryRatesService.param(PARAM_TO, to);
         return fmpTreasuryRatesService.download();

src/main/java/dev/sorn/fmp4j/clients/FmpEtfClient.java

@@ -16,14 +16,15 @@
 import dev.sorn.fmp4j.services.FmpEtfSectorWeightingService;
 import dev.sorn.fmp4j.services.FmpService;
 import dev.sorn.fmp4j.types.FmpSymbol;
+import java.util.List;
 
 public class FmpEtfClient {
     // Alphabetical order
-    protected final FmpService<FmpEtfAssetExposure[]> etfAssetExposureService;
-    protected final FmpService<FmpEtfCountryWeighting[]> etfCountryWeightingService;
-    protected final FmpService<FmpEtfHolding[]> etfHoldingService;
-    protected final FmpService<FmpEtfInfo[]> etfInfoService;
-    protected final FmpService<FmpEtfSectorWeighting[]> etfSectorWeightingService;
+    protected final FmpService<FmpEtfAssetExposure> etfAssetExposureService;
+    protected final FmpService<FmpEtfCountryWeighting> etfCountryWeightingService;
+    protected final FmpService<FmpEtfHolding> etfHoldingService;
+    protected final FmpService<FmpEtfInfo> etfInfoService;
+    protected final FmpService<FmpEtfSectorWeighting> etfSectorWeightingService;
 
     public FmpEtfClient(FmpConfig fmpConfig, FmpHttpClient fmpHttpClient) {
         this.etfAssetExposureService = new FmpEtfAssetExposureService(fmpConfig, fmpHttpClient);
@@ -33,27 +34,27 @@
         this.etfSectorWeightingService = new FmpEtfSectorWeightingService(fmpConfig, fmpHttpClient);
     }
 
-    public synchronized FmpEtfAssetExposure[] assetExposure(FmpSymbol symbol) {
+    public synchronized List<FmpEtfAssetExposure> assetExposure(FmpSymbol symbol) {
         etfAssetExposureService.param(PARAM_SYMBOL, symbol);
         return etfAssetExposureService.download();
     }
 
-    public synchronized FmpEtfCountryWeighting[] countryWeightings(FmpSymbol symbol) {
+    public synchronized List<FmpEtfCountryWeighting> countryWeightings(FmpSymbol symbol) {
         etfCountryWeightingService.param(PARAM_SYMBOL, symbol);
         return etfCountryWeightingService.download();
     }
 
-    public synchronized FmpEtfHolding[] holdings(FmpSymbol symbol) {
+    public synchronized List<FmpEtfHolding> holdings(FmpSymbol symbol) {
         etfHoldingService.param(PARAM_SYMBOL, symbol);
         return etfHoldingService.download();
     }
 
-    public synchronized FmpEtfInfo[] info(FmpSymbol symbol) {
+    public synchronized List<FmpEtfInfo> info(FmpSymbol symbol) {
         etfInfoService.param(PARAM_SYMBOL, symbol);
         return etfInfoService.download();
     }
 
-    public synchronized FmpEtfSectorWeighting[] sectorWeightings(FmpSymbol symbol) {
+    public synchronized List<FmpEtfSectorWeighting> sectorWeightings(FmpSymbol symbol) {
         etfSectorWeightingService.param(PARAM_SYMBOL, symbol);
         return etfSectorWeightingService.download();
     }