@passly-nl/data 0.1.0

package/src/dto/ticket/TicketDto.ts

@@ -0,0 +1,131 @@
+import { dto } from '@basmilius/http-client';
+import type { DateTime } from 'luxon';
+import type { BuyerDto, EventDto, OrderDto, ProductDto } from '#data/dto';
+import type { ScanStatus, TicketValidity } from '#data/types';
+
+@dto
+export class TicketDto {
+    get id(): string {
+        return this.#id;
+    }
+
+    set id(value: string) {
+        this.#id = value;
+    }
+
+    get sequence(): number {
+        return this.#sequence;
+    }
+
+    set sequence(value: number) {
+        this.#sequence = value;
+    }
+
+    get code(): string {
+        return this.#code;
+    }
+
+    set code(value: string) {
+        this.#code = value;
+    }
+
+    get status(): ScanStatus {
+        return this.#status;
+    }
+
+    set status(value: ScanStatus) {
+        this.#status = value;
+    }
+
+    get validity(): TicketValidity {
+        return this.#validity;
+    }
+
+    set validity(value: TicketValidity) {
+        this.#validity = value;
+    }
+
+    get buyer(): BuyerDto {
+        return this.#buyer;
+    }
+
+    set buyer(value: BuyerDto) {
+        this.#buyer = value;
+    }
+
+    get event(): EventDto {
+        return this.#event;
+    }
+
+    set event(value: EventDto) {
+        this.#event = value;
+    }
+
+    get holder(): BuyerDto | null {
+        return this.#holder;
+    }
+
+    set holder(value: BuyerDto | null) {
+        this.#holder = value;
+    }
+
+    get order(): OrderDto {
+        return this.#order;
+    }
+
+    set order(value: OrderDto) {
+        this.#order = value;
+    }
+
+    get product(): ProductDto {
+        return this.#product;
+    }
+
+    set product(value: ProductDto) {
+        this.#product = value;
+    }
+
+    get createdOn(): DateTime {
+        return this.#createdOn;
+    }
+
+    set createdOn(value: DateTime) {
+        this.#createdOn = value;
+    }
+
+    get updatedOn(): DateTime {
+        return this.#updatedOn;
+    }
+
+    set updatedOn(value: DateTime) {
+        this.#updatedOn = value;
+    }
+
+    #id: string;
+    #sequence: number;
+    #code: string;
+    #status: ScanStatus;
+    #validity: TicketValidity;
+    #buyer: BuyerDto;
+    #event: EventDto;
+    #holder: BuyerDto | null;
+    #order: OrderDto;
+    #product: ProductDto;
+    #createdOn: DateTime;
+    #updatedOn: DateTime;
+
+    constructor(id: string, sequence: number, code: string, status: ScanStatus, validity: TicketValidity, buyer: BuyerDto, event: EventDto, holder: BuyerDto | null, order: OrderDto, product: ProductDto, createdOn: DateTime, updatedOn: DateTime) {
+        this.#id = id;
+        this.#sequence = sequence;
+        this.#code = code;
+        this.#status = status;
+        this.#validity = validity;
+        this.#buyer = buyer;
+        this.#event = event;
+        this.#holder = holder;
+        this.#order = order;
+        this.#product = product;
+        this.#createdOn = createdOn;
+        this.#updatedOn = updatedOn;
+    }
+}

package/src/dto/ticket/index.ts

@@ -0,0 +1 @@
+export { TicketDto } from './TicketDto';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './adapter';
+export * from './dto';
+export * from './service';
+export * from './types';
+export * from './util';

package/src/service/AuthService.ts

@@ -0,0 +1,71 @@
+import { BaseResponse, BaseService, type Paginated, QueryString } from '@basmilius/http-client';
+import { AuthAdapter } from '#data/adapter';
+import type { UserTokenDto } from '#data/dto';
+import type { Claim } from '#data/types';
+
+export class AuthService extends BaseService {
+    async get(): Promise<BaseResponse<UserTokenDto>> {
+        return await this
+            .request('/auth')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(AuthAdapter.parseUserTokenFromObject);
+    }
+
+    async getClaims(): Promise<BaseResponse<Claim[]>> {
+        return await this
+            .request('/auth/claims')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(r => Object.values(r) as Claim[]);
+    }
+
+    async getPasswordCompromised(): Promise<BaseResponse<boolean>> {
+        return await this
+            .request('/auth/password-compromised')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runDataKey<{ readonly compromised: boolean; }>('compromised');
+    }
+
+    async getSessions(offset: number, limit: number): Promise<BaseResponse<Paginated<UserTokenDto>>> {
+        return await this
+            .request('/auth/sessions')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .append('offset', offset)
+                .append('limit', limit))
+            .runPaginatedAdapter(AuthAdapter.parseUserTokenFromObject);
+    }
+
+    async post(email: string, password: string, code?: string): Promise<BaseResponse<UserTokenDto>> {
+        return await this
+            .request('/auth')
+            .method('post')
+            .body({email, password, code})
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(AuthAdapter.parseUserTokenFromObject);
+    }
+
+    async deleteSession(token: string): Promise<BaseResponse<never>> {
+        return await this
+            .request('/auth/sessions')
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                token
+            })
+            .runEmpty();
+    }
+}

package/src/service/InvitationService.ts

@@ -0,0 +1,35 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { AuthAdapter, CommonAdapter, MerchantAdapter } from '#data/adapter';
+import type { InvitationDto, StatusResponseDto, UserTokenDto } from '#data/dto';
+
+export class InvitationService extends BaseService {
+    async get(invitationId: string): Promise<BaseResponse<InvitationDto>> {
+        return await this
+            .request(`/invitations/${invitationId}`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(MerchantAdapter.parseInvitationFromObject);
+    }
+
+    async postAccept(invitationId: string, password?: string): Promise<BaseResponse<UserTokenDto>> {
+        return await this
+            .request(`/invitations/${invitationId}/accept`)
+            .method('post')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                password
+            })
+            .runAdapter(AuthAdapter.parseUserTokenFromObject);
+    }
+
+    async postDecline(invitationId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/invitations/${invitationId}/decline`)
+            .method('post')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+}

package/src/service/MeService.ts

@@ -0,0 +1,106 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { AuthAdapter, CommonAdapter } from '#data/adapter';
+import type { StatusResponseDto, TotpStateDto, UserDto } from '#data/dto';
+
+export class MeService extends BaseService {
+    async get(): Promise<BaseResponse<UserDto>> {
+        return await this
+            .request('/me')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(AuthAdapter.parseUserFromObject);
+    }
+
+    async getTotp(): Promise<BaseResponse<TotpStateDto>> {
+        return await this
+            .request('/me/totp')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(AuthAdapter.parseTotpStateFromObject);
+    }
+
+    async post(firstName: string, lastName: string, phoneNumber: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request('/me')
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                first_name: firstName,
+                last_name: lastName,
+                phone_number: phoneNumber
+            })
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async postChangePassword(password: string, newPassword: string, newPasswordConfirm: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request('/me/change-password')
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                password,
+                new_password: newPassword,
+                new_password_confirm: newPasswordConfirm
+            })
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async postProfilePicture(picture: File): Promise<BaseResponse<StatusResponseDto>> {
+        const data = new FormData();
+        data.append('file', picture);
+
+        return await this
+            .request('/me/profile-picture')
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body(data)
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async postTotp(secret: string, code: string): Promise<BaseResponse<TotpStateDto>> {
+        return await this
+            .request('/me/totp')
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                secret,
+                code
+            })
+            .runAdapter(AuthAdapter.parseTotpStateFromObject);
+    }
+
+    async deleteProfilePicture(): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request('/me/profile-picture')
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async deleteTotp(code: string): Promise<BaseResponse<TotpStateDto>> {
+        return await this
+            .request('/me/totp')
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                code
+            })
+            .runAdapter(AuthAdapter.parseTotpStateFromObject);
+    }
+}

package/src/service/MerchantBuyerService.ts

@@ -0,0 +1,37 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BuyerAdapter, OrderAdapter } from '#data/adapter';
+import type { BuyerDto, OrderDto } from '#data/dto';
+
+export class MerchantBuyerService extends BaseService {
+    async get(merchantId: string, buyerId: string): Promise<BaseResponse<BuyerDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/buyers/${buyerId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(BuyerAdapter.parseBuyerFromObject);
+    }
+
+    async getOrder(merchantId: string, buyerId: string, orderId: string): Promise<BaseResponse<OrderDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/buyers/${buyerId}/orders/${orderId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(OrderAdapter.parseOrderFromObject);
+    }
+
+    async getOrders(merchantId: string, buyerId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<OrderDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/buyers/${buyerId}/orders`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .append('offset', offset)
+                .append('limit', limit))
+            .runPaginatedAdapter(OrderAdapter.parseOrderFromObject);
+    }
+}

package/src/service/MerchantBuyersService.ts

@@ -0,0 +1,17 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BuyerAdapter } from '#data/adapter';
+import type { BuyerDto } from '#data/dto';
+
+export class MerchantBuyersService extends BaseService {
+    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<BuyerDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/buyers`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .append('offset', offset)
+                .append('limit', limit))
+            .bearerToken()
+            .runPaginatedAdapter(BuyerAdapter.parseBuyerFromObject);
+    }
+}

package/src/service/MerchantDashboardService.ts

@@ -0,0 +1,23 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { MerchantDashboardAdapter } from '#data/adapter';
+import type { MerchantDashboardKeyMetricsDto, MerchantDashboardUpcomingEventDto } from '#data/dto';
+
+export class MerchantDashboardService extends BaseService {
+    async getKeyMetrics(merchantId: string): Promise<BaseResponse<MerchantDashboardKeyMetricsDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/dashboard/key-metrics`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(MerchantDashboardAdapter.parseKeyMetricsFromObject);
+    }
+
+    async getUpcomingEvents(merchantId: string): Promise<BaseResponse<MerchantDashboardUpcomingEventDto[]>> {
+        return await this
+            .request(`/merchants/${merchantId}/dashboard/upcoming-events`)
+            .method('get')
+            .bearerToken()
+            .runArrayAdapter(MerchantDashboardAdapter.parseUpcomingEventFromObject);
+    }
+}

package/src/service/MerchantEventProductService.ts

@@ -0,0 +1,76 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { ProductAdapter } from '#data/adapter';
+import type { ProductDto } from '#data/dto';
+
+export class MerchantEventProductService extends BaseService {
+    async get(merchantId: string, eventId: string, productId: string): Promise<BaseResponse<ProductDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/${productId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(ProductAdapter.parseProductFromObject);
+    }
+
+    async postImage(merchantId: string, eventId: string, productId: string, picture: File): Promise<BaseResponse<object>> {
+        const data = new FormData();
+        data.append('file', picture);
+
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/${productId}/media`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body(data)
+            .runAdapter(r => r);
+    }
+
+    async patch(merchantId: string, eventId: string, productId: string, product: ProductDto): Promise<BaseResponse<ProductDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/${productId}`)
+            .method('patch')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                name: product.name,
+                description: product.description,
+                price: product.price.cents,
+                max_quantity: product.maxQuantity,
+                is_swappable: product.isSwappable
+            })
+            .runAdapter(ProductAdapter.parseProductFromObject);
+    }
+
+    async patchPause(merchantId: string, eventId: string, productId: string): Promise<BaseResponse<never>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/${productId}/pause`)
+            .method('patch')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runEmpty();
+    }
+
+    async patchResume(merchantId: string, eventId: string, productId: string): Promise<BaseResponse<never>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/${productId}/resume`)
+            .method('patch')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runEmpty();
+    }
+
+    async delete(merchantId: string, eventId: string, productId: string): Promise<BaseResponse<never>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/${productId}`)
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runEmpty();
+    }
+}

package/src/service/MerchantEventProductsService.ts

@@ -0,0 +1,48 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import type { FluxFormSelectEntry } from '@flux-ui/types';
+import { FluxAdapter, ProductAdapter } from '#data/adapter';
+import type { ProductDto } from '#data/dto';
+
+export class MerchantEventProductsService extends BaseService {
+    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<ProductDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .append('offset', offset)
+                .append('limit', limit))
+            .runPaginatedAdapter(ProductAdapter.parseProductFromObject);
+    }
+
+    async getSelectOptions(merchantId: string, eventId: string, searchQuery: string | null = null, ids: string[] | null = null): Promise<BaseResponse<FluxFormSelectEntry[]>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products/select-options`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .appendArray('ids[]', ids)
+                .append('searchQuery', searchQuery))
+            .runArrayAdapter(FluxAdapter.parseFluxFormSelectEntryFromObject);
+    }
+
+    async post(merchantId: string, eventId: string, name: string, description: string, price: number, maxQuantity: number, stock: number | null, stockPoolId: string | null): Promise<BaseResponse<ProductDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/products`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                name,
+                description,
+                price,
+                stock,
+                max_quantity: maxQuantity,
+                stock_pool_id: stockPoolId
+            })
+            .runAdapter(ProductAdapter.parseProductFromObject);
+    }
+}

package/src/service/MerchantEventService.ts

@@ -0,0 +1,115 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { CommonAdapter, EventAdapter } from '#data/adapter';
+import type { EventAvailabilityDto, EventCountersDto, EventDto, StatusResponseDto } from '#data/dto';
+import { emptyNull } from '#data/util';
+
+export class MerchantEventService extends BaseService {
+    async get(merchantId: string, eventId: string): Promise<BaseResponse<EventDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(EventAdapter.parseEventFromObject);
+    }
+
+    async getAvailability(merchantId: string, eventId: string): Promise<BaseResponse<EventAvailabilityDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/availability`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(EventAdapter.parseEventAvailabilityFromObject);
+    }
+
+    async getCounters(merchantId: string, eventId: string): Promise<BaseResponse<EventCountersDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/counters`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(EventAdapter.parseEventCountersFromObject);
+    }
+
+    async post(merchantId: string, event: EventDto): Promise<BaseResponse<EventDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${event.id}`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                name: event.name,
+                description: event.description,
+                starts_on: event.startsOn.toISO(),
+                ends_on: event.endsOn.toISO(),
+                minimum_age: event.minimumAge,
+                address: {
+                    label: emptyNull(event.address.label),
+                    street: event.address.street,
+                    number: event.address.number,
+                    postal_code: event.address.postalCode,
+                    city: event.address.city,
+                    country_code: event.address.country
+                }
+            })
+            .runAdapter(EventAdapter.parseEventFromObject);
+    }
+
+    async postHeader(merchantId: string, eventId: string, picture: File): Promise<BaseResponse<StatusResponseDto>> {
+        const data = new FormData();
+        data.append('file', picture);
+
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/header`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body(data)
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async postPublish(merchantId: string, eventId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/publish`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async postUnpublish(merchantId: string, eventId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/unpublish`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async delete(merchantId: string, eventId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}`)
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async deleteHeader(merchantId: string, eventId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/header`)
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+}