@passly-nl/data 1.0.0-beta.2 → 1.0.0-beta.5

package/src/adapter/FinanceAdapter.ts

@@ -1,40 +1,40 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { DateTimeAdapter, PaymentAdapter } from '#data/adapter';
 import { FinanceOverviewDto, InvoiceDto, InvoiceLineDto } from '#data/dto';
 import { optionalArray } from '#data/util';
 
 @adapter
 export class FinanceAdapter {
-    static parseFinanceOverviewFromObject(overview: Record<string, any>): FinanceOverviewDto {
+    static parseFinanceOverview(data: ForeignData): FinanceOverviewDto {
         return new FinanceOverviewDto(
-            PaymentAdapter.parseCostFromObject(overview.estimated_payment_cost),
-            overview.orders,
-            PaymentAdapter.parseCostFromObject(overview.platform_cost),
-            PaymentAdapter.parseCostFromObject(overview.revenue)
+            PaymentAdapter.parseCost(data.estimated_payment_cost),
+            data.orders,
+            PaymentAdapter.parseCost(data.platform_cost),
+            PaymentAdapter.parseCost(data.revenue)
         );
     }
 
-    static parseInvoiceFromObject(invoice: Record<string, any>): InvoiceDto {
+    static parseInvoice(data: ForeignData): InvoiceDto {
         return new InvoiceDto(
-            invoice.id,
-            invoice.number,
-            invoice.sequence,
-            invoice.status,
-            invoice.year,
-            PaymentAdapter.parseCostFromObject(invoice.total),
-            optionalArray(invoice.lines, FinanceAdapter.parseInvoiceLineFromObject)!,
-            DateTimeAdapter.parseDateTimeFromString(invoice.created_on),
-            DateTimeAdapter.parseDateTimeFromString(invoice.updated_on)
+            data.id,
+            data.number,
+            data.sequence,
+            data.status,
+            data.year,
+            PaymentAdapter.parseCost(data.total),
+            optionalArray(data.lines, FinanceAdapter.parseInvoiceLine)!,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on)
         );
     }
 
-    static parseInvoiceLineFromObject(line: Record<string, any>): InvoiceLineDto {
+    static parseInvoiceLine(data: ForeignData): InvoiceLineDto {
         return new InvoiceLineDto(
-            line.id,
-            line.type,
-            PaymentAdapter.parseCostFromObject(line.cost),
-            DateTimeAdapter.parseDateTimeFromString(line.created_on),
-            DateTimeAdapter.parseDateTimeFromString(line.updated_on)
+            data.id,
+            data.type,
+            PaymentAdapter.parseCost(data.cost),
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on)
         );
     }
 }

package/src/adapter/FluxAdapter.ts

@@ -1,21 +1,21 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import type { FluxFormSelectEntry, FluxFormSelectGroup, FluxFormSelectOption } from '@flux-ui/types';
 
 @adapter
 export class FluxAdapter {
-    static parseFluxFormSelectEntryFromObject(entry: object): FluxFormSelectEntry {
-        if ('value' in entry) {
-            return FluxAdapter.parseFluxFormSelectOptionFromObject(entry);
+    static parseFluxFormSelectEntry(data: ForeignData): FluxFormSelectEntry {
+        if ('value' in data) {
+            return FluxAdapter.parseFluxFormSelectOption(data);
         }
 
-        return FluxAdapter.parseFluxFormSelectGroupFromObject(entry);
+        return FluxAdapter.parseFluxFormSelectGroup(data);
     }
 
-    static parseFluxFormSelectGroupFromObject(group: object): FluxFormSelectGroup {
-        return group as FluxFormSelectGroup;
+    static parseFluxFormSelectGroup(data: ForeignData): FluxFormSelectGroup {
+        return data as FluxFormSelectGroup;
     }
 
-    static parseFluxFormSelectOptionFromObject(option: object): FluxFormSelectOption {
-        return option as FluxFormSelectOption;
+    static parseFluxFormSelectOption(data: ForeignData): FluxFormSelectOption {
+        return data as FluxFormSelectOption;
     }
 }

package/src/adapter/MerchantAdapter.ts

@@ -1,70 +1,70 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { AddressAdapter, AuthAdapter, DateTimeAdapter, FileSystemAdapter, PaymentAdapter } from '#data/adapter';
 import { ContractDto, InvitationDto, MerchantDto, MerchantUserDto, VatNumberDto } from '#data/dto';
 import { optional } from '#data/util';
 
 @adapter
 export class MerchantAdapter {
-    static parseContractFromObject(contract: Record<string, any>): ContractDto {
+    static parseContract(data: ForeignData): ContractDto {
         return new ContractDto(
-            contract.id,
-            DateTimeAdapter.parseDateTimeFromString(contract.starts_on),
-            DateTimeAdapter.parseDateTimeFromString(contract.ends_on),
-            PaymentAdapter.parseCostFromObject(contract.fee),
-            contract.remark
+            data.id,
+            DateTimeAdapter.parseDateTime(data.starts_on),
+            DateTimeAdapter.parseDateTime(data.ends_on),
+            PaymentAdapter.parseCost(data.fee),
+            data.remark
         );
     }
 
-    static parseInvitationFromObject(invitation: Record<string, any>): InvitationDto {
+    static parseInvitation(data: ForeignData): InvitationDto {
         return new InvitationDto(
-            invitation.id,
-            invitation.merchant_id,
-            invitation.user_id,
-            invitation.claims,
-            invitation.is_new_user,
-            DateTimeAdapter.parseDateTimeFromString(invitation.created_on),
-            DateTimeAdapter.parseDateTimeFromString(invitation.updated_on),
-            MerchantAdapter.parseMerchantFromObject(invitation.merchant),
-            AuthAdapter.parseUserFromObject(invitation.user)
+            data.id,
+            data.merchant_id,
+            data.user_id,
+            data.claims,
+            data.is_new_user,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on),
+            MerchantAdapter.parseMerchant(data.merchant),
+            AuthAdapter.parseUser(data.user)
         );
     }
 
-    static parseMerchantFromObject(merchant: Record<string, any>): MerchantDto {
+    static parseMerchant(data: ForeignData): MerchantDto {
         return new MerchantDto(
-            merchant.id,
-            merchant.name,
-            merchant.email,
-            merchant.phone_number,
-            merchant.url,
-            merchant.chamber_of_commerce_number,
-            merchant.vat_number,
-            merchant.currency,
-            optional(merchant.address, AddressAdapter.parseAddressFromObject),
-            optional(merchant.current_contract, MerchantAdapter.parseContractFromObject),
-            optional(merchant.logo, FileSystemAdapter.parsePictureFromObject),
-            optional(merchant.created_on, DateTimeAdapter.parseDateTimeFromString),
-            optional(merchant.updated_on, DateTimeAdapter.parseDateTimeFromString)
+            data.id,
+            data.name,
+            data.email,
+            data.phone_number,
+            data.url,
+            data.chamber_of_commerce_number,
+            data.vat_number,
+            data.currency,
+            optional(data.address, AddressAdapter.parseAddress),
+            optional(data.current_contract, MerchantAdapter.parseContract),
+            optional(data.logo, FileSystemAdapter.parsePicture),
+            optional(data.created_on, DateTimeAdapter.parseDateTime),
+            optional(data.updated_on, DateTimeAdapter.parseDateTime)
         );
     }
 
-    static parseMerchantUserFromObject(merchantUser: Record<string, any>): MerchantUserDto {
+    static parseMerchantUser(data: ForeignData): MerchantUserDto {
         return new MerchantUserDto(
-            merchantUser.is_manager,
-            DateTimeAdapter.parseDateTimeFromString(merchantUser.created_on),
-            DateTimeAdapter.parseDateTimeFromString(merchantUser.updated_on),
-            AuthAdapter.parseUserFromObject(merchantUser.user)
+            data.is_manager,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on),
+            AuthAdapter.parseUser(data.user)
         );
     }
 
-    static parseVatNumberFromObject(vatNumber: Record<string, any>): VatNumberDto {
+    static parseVatNumber(data: ForeignData): VatNumberDto {
         return new VatNumberDto(
-            vatNumber.id,
-            vatNumber.vat_number,
-            vatNumber.name,
-            vatNumber.address,
-            vatNumber.country_code,
-            DateTimeAdapter.parseDateTimeFromString(vatNumber.created_on),
-            DateTimeAdapter.parseDateTimeFromString(vatNumber.updated_on)
+            data.id,
+            data.vat_number,
+            data.name,
+            data.address,
+            data.country_code,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on)
         );
     }
 }

package/src/adapter/MerchantDashboardAdapter.ts

@@ -1,29 +1,29 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { DateTimeAdapter, FileSystemAdapter } from '#data/adapter';
 import { MerchantDashboardKeyMetricsDto, MerchantDashboardUpcomingEventDto } from '#data/dto';
 
 @adapter
 export class MerchantDashboardAdapter {
-    static parseKeyMetricsFromObject(keyMetrics: Record<string, any>): MerchantDashboardKeyMetricsDto {
+    static parseKeyMetrics(data: ForeignData): MerchantDashboardKeyMetricsDto {
         return new MerchantDashboardKeyMetricsDto(
-            keyMetrics.revenue,
-            keyMetrics.tickets,
-            keyMetrics.events,
-            keyMetrics.tasks
+            data.revenue,
+            data.tickets,
+            data.events,
+            data.tasks
         );
     }
 
-    static parseUpcomingEventFromObject(event: Record<string, any>): MerchantDashboardUpcomingEventDto {
+    static parseUpcomingEvent(data: ForeignData): MerchantDashboardUpcomingEventDto {
         return new MerchantDashboardUpcomingEventDto(
-            event.id,
-            event.name,
-            event.description,
-            FileSystemAdapter.parsePictureFromObject(event.header_file),
-            event.status,
-            DateTimeAdapter.parseDateTimeFromString(event.starts_on),
-            event.tickets_sold,
-            event.tickets_total,
-            event.sell_through_rate
+            data.id,
+            data.name,
+            data.description,
+            FileSystemAdapter.parsePicture(data.header_file),
+            data.status,
+            DateTimeAdapter.parseDateTime(data.starts_on),
+            data.tickets_sold,
+            data.tickets_total,
+            data.sell_through_rate
         );
     }
 }

package/src/adapter/OrderAdapter.ts

@@ -1,55 +1,55 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { BuyerAdapter, DateTimeAdapter, EventAdapter, PaymentAdapter, PublicShopAdapter } from '#data/adapter';
 import { OrderDto, OrderLineDto, OrderPaymentProviderDto, OrderProductDto } from '#data/dto';
 import { optional, optionalArray } from '#data/util';
 
 @adapter
 export class OrderAdapter {
-    static parseOrderFromObject(order: Record<string, any>): OrderDto {
+    static parseOrder(data: ForeignData): OrderDto {
         return new OrderDto(
-            order.id,
-            order.code,
-            order.origin,
-            order.type,
-            DateTimeAdapter.parseDateTimeFromString(order.created_on),
-            optional(order.payment_provider, OrderAdapter.parseOrderPaymentProviderFromObject),
-            optional(order.platform_cost, PaymentAdapter.parseCostFromObject)!,
-            optional(order.sub_total, PaymentAdapter.parseCostFromObject)!,
-            optional(order.total, PaymentAdapter.parseCostFromObject)!,
-            order.url,
-            optional(order.buyer, BuyerAdapter.parseBuyerFromObject),
-            optional(order.event, EventAdapter.parseEventFromObject),
-            optionalArray(order.lines, OrderAdapter.parseOrderLineFromObject),
-            optional(order.shop, PublicShopAdapter.parsePublicShopFromObject),
-            optional(order.transaction, PaymentAdapter.parseTransactionFromObject)
+            data.id,
+            data.code,
+            data.origin,
+            data.type,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            optional(data.payment_provider, OrderAdapter.parseOrderPaymentProvider),
+            optional(data.platform_cost, PaymentAdapter.parseCost)!,
+            optional(data.sub_total, PaymentAdapter.parseCost)!,
+            optional(data.total, PaymentAdapter.parseCost)!,
+            data.url,
+            optional(data.buyer, BuyerAdapter.parseBuyer),
+            optional(data.event, EventAdapter.parseEvent),
+            optionalArray(data.lines, OrderAdapter.parseOrderLine),
+            optional(data.shop, PublicShopAdapter.parsePublicShop),
+            optional(data.transaction, PaymentAdapter.parseTransaction)
         );
     }
 
-    static parseOrderLineFromObject(line: Record<string, any>): OrderLineDto {
+    static parseOrderLine(data: ForeignData): OrderLineDto {
         return new OrderLineDto(
-            line.id,
-            PaymentAdapter.parseCostFromObject(line.price),
-            line.quantity,
-            OrderAdapter.parseOrderProductFromObject(line.product),
-            PaymentAdapter.parseCostFromObject(line.sub_total),
-            DateTimeAdapter.parseDateTimeFromString(line.created_on),
-            DateTimeAdapter.parseDateTimeFromString(line.updated_on)
+            data.id,
+            PaymentAdapter.parseCost(data.price),
+            data.quantity,
+            OrderAdapter.parseOrderProduct(data.product),
+            PaymentAdapter.parseCost(data.sub_total),
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on)
         );
     }
 
-    static parseOrderPaymentProviderFromObject(provider: Record<string, any>): OrderPaymentProviderDto {
+    static parseOrderPaymentProvider(data: ForeignData): OrderPaymentProviderDto {
         return new OrderPaymentProviderDto(
-            provider.name,
-            provider.url
+            data.name,
+            data.url
         );
     }
 
-    static parseOrderProductFromObject(product: Record<string, any>): OrderProductDto {
+    static parseOrderProduct(data: ForeignData): OrderProductDto {
         return new OrderProductDto(
-            product.id,
-            product.name,
-            product.description,
-            product.image
+            data.id,
+            data.name,
+            data.description,
+            data.image
         );
     }
 }

package/src/adapter/PaymentAdapter.ts

@@ -1,48 +1,48 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { OrderAdapter } from '#data/adapter';
 import { CostDto, PaymentMethodDto, PaymentProviderDto, TransactionDto } from '#data/dto';
 import { optional } from '#data/util';
 
 @adapter
 export class PaymentAdapter {
-    static parseCostFromObject(cost: Record<string, any>): CostDto {
+    static parseCost(data: ForeignData): CostDto {
         return new CostDto(
-            cost.currency_code,
-            cost.currency_decimals,
-            cost.currency_sign,
-            cost.decimal,
-            cost.formatted,
-            cost.value
+            data.currency_code,
+            data.currency_decimals,
+            data.currency_sign,
+            data.decimal,
+            data.formatted,
+            data.value
         );
     }
 
-    static parsePaymentMethodFromObject(method: Record<string, any>): PaymentMethodDto {
+    static parsePaymentMethod(data: ForeignData): PaymentMethodDto {
         return new PaymentMethodDto(
-            method.id,
-            method.name,
-            method.image
+            data.id,
+            data.name,
+            data.image
         );
     }
 
-    static parsePaymentProviderFromObject(provider: Record<string, any>): PaymentProviderDto {
+    static parsePaymentProvider(data: ForeignData): PaymentProviderDto {
         return new PaymentProviderDto(
-            provider.id,
-            provider.type,
-            provider.methods.map(PaymentAdapter.parsePaymentMethodFromObject)
+            data.id,
+            data.type,
+            data.methods.map(PaymentAdapter.parsePaymentMethod)
         );
     }
 
-    static parseTransactionFromObject(transaction: Record<string, any>): TransactionDto {
+    static parseTransaction(data: ForeignData): TransactionDto {
         return new TransactionDto(
-            transaction.id,
-            transaction.description,
-            transaction.status,
-            PaymentAdapter.parseCostFromObject(transaction.cost),
-            transaction.metadata,
-            transaction.external_checkout_url,
-            transaction.external_details,
-            optional(transaction.order, OrderAdapter.parseOrderFromObject),
-            optional(transaction.payment_method, PaymentAdapter.parsePaymentMethodFromObject)
+            data.id,
+            data.description,
+            data.status,
+            PaymentAdapter.parseCost(data.cost),
+            data.metadata,
+            data.external_checkout_url,
+            data.external_details,
+            optional(data.order, OrderAdapter.parseOrder),
+            optional(data.payment_method, PaymentAdapter.parsePaymentMethod)
         );
     }
 }

package/src/adapter/ProductAdapter.ts

@@ -1,24 +1,24 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { EventAdapter, FileSystemAdapter, PaymentAdapter } from '#data/adapter';
 import { ProductDto } from '#data/dto';
 import { optional, optionalArray } from '#data/util';
 
 @adapter
 export class ProductAdapter {
-    static parseProductFromObject(product: Record<string, any>): ProductDto {
+    static parseProduct(data: ForeignData): ProductDto {
         return new ProductDto(
-            product.id,
-            product.type,
-            product.name,
-            product.description,
-            optional(product.price, PaymentAdapter.parseCostFromObject),
-            product.max_quantity,
-            product.is_active,
-            product.is_swappable,
-            product.remaining_stock,
-            optional(product.stock_pool, EventAdapter.parseStockPoolFromObject),
-            optional(product.image, FileSystemAdapter.parsePictureFromObject),
-            optionalArray(product.images, FileSystemAdapter.parsePictureFromObject)!
+            data.id,
+            data.type,
+            data.name,
+            data.description,
+            optional(data.price, PaymentAdapter.parseCost),
+            data.max_quantity,
+            data.is_active,
+            data.is_swappable,
+            data.remaining_stock,
+            optional(data.stock_pool, EventAdapter.parseStockPool),
+            optional(data.image, FileSystemAdapter.parsePicture),
+            optionalArray(data.images, FileSystemAdapter.parsePicture)!
         );
     }
 }

package/src/adapter/PublicPayAdapter.ts

@@ -1,13 +1,13 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { PublicPaymentMethodDto } from '#data/dto';
 
 @adapter
 export class PublicPayAdapter {
-    static parsePublicPaymentMethodFromObject(method: Record<string, any>): PublicPaymentMethodDto {
+    static parsePublicPaymentMethod(data: ForeignData): PublicPaymentMethodDto {
         return new PublicPaymentMethodDto(
-            method.id,
-            method.name,
-            method.image
+            data.id,
+            data.name,
+            data.image
         );
     }
 }