@ferryrsvp/liknoss-client 1.0.3

package/README.md

@@ -0,0 +1,39 @@
+# @ferryrsvp/liknoss-client
+
+Typed Liknoss B2C client for Ferry RSVP services and workers.
+
+## Install
+
+```bash
+npm install @ferryrsvp/liknoss-client
+```
+
+## Usage
+
+```ts
+import { createLiknossClient } from "@ferryrsvp/liknoss-client";
+
+const client = createLiknossClient({
+  baseUrl: "https://example.com/b2c",
+  fetch,
+});
+
+const countries = await client.catalog.listCountries();
+const locations = await client.catalog.listLocations();
+```
+
+## Notes
+
+- The client ships ESM output and TypeScript declarations.
+- For server-side Ferry RSVP usage, prefer passing `defaultHeaders` or a custom `fetch` implementation when upstream authentication headers must be injected.
+- OpenAPI generation lives in the repository build flow; consumers only need the published build artifacts.
+
+## Publishing
+
+This package is configured for public npm publishing.
+
+- `npm run build`
+- `npm publish`
+
+For GitHub Actions publishing, provide an `NPM_TOKEN` repository secret.
+

package/build/liknoss-client/client.d.ts

@@ -0,0 +1,52 @@
+import type { LiknossClientOptions } from "./core/types";
+export declare function createLiknossClient(options?: LiknossClientOptions): {
+    accommodation: {
+        getAccommodationPlan: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/accommodation-plan">;
+        lockAccommodationSpace: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/lock-accommodation-space">;
+        unlockAccommodationSpace: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/unlock-accommodation-space">;
+    };
+    booking: {
+        cancelBooking: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/cancellation/{crs_reservation_id}">;
+        cancelMultiBooking: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/cancel-multi-booking/{crs_reservation_id}">;
+        confirmPayment: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/confirm-payment">;
+        createBooking: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/booking">;
+        createBookingIdentifier: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/booking-identifier">;
+        createMultiBooking: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/multi-booking">;
+        generateVoucher: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/generate-voucher/{crs_reservation_id}">;
+        getBookingLeader: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/retrieve-booking-leader/{crs_reservation_id}">;
+        getMultiPricing: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/multi-pricing">;
+        getPricing: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/pricing">;
+    };
+    catalog: {
+        filterLocations: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/locations-with-filter">;
+        filterRoutes: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/routes-with-filter">;
+        getCompanyFinancialData: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/financial-data/{company_abbreviation}">;
+        getCompanyRedirection: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/company-redirection">;
+        getResidentStaticData: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/resident-static-data">;
+        getSession: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/session">;
+        listAnalyticRoutes: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/analytic-routes">;
+        listCompanies: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/companies">;
+        listCountries: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/countries">;
+        listLocations: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/locations">;
+        listRoutes: import("./core/types").LiknossGetMethod<"/web-services/v200/b2c/routes">;
+    };
+    insurance: {
+        getInsuranceOffer: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/insurance-offer">;
+        retrieveInsurance: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/insurance-retrieve">;
+    };
+    transport: import("./core/types").LiknossTransport;
+    trips: {
+        getAvailability: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/availability">;
+        getRouteFrequencies: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/route-frequency">;
+        listTrips: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/list-of-trips">;
+        searchSimpleTrips: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/simple-trips">;
+        searchTrips: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/trips">;
+        searchTripsPerDay: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/trips-per-day">;
+        searchTripsWithConjunction: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/trips-with-conjunction">;
+    };
+    validation: {
+        validateLoyaltyData: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/validate-loyalty-data">;
+        validateResidentData: import("./core/types").LiknossPostMethod<"/web-services/v200/b2c/validate-resident-data">;
+    };
+};
+export type LiknossClient = ReturnType<typeof createLiknossClient>;

package/build/liknoss-client/core/errors.d.ts

@@ -0,0 +1,59 @@
+import type { LiknossResponseMeta, LiknossWarning } from "./types";
+interface LiknossErrorOptions {
+    cause?: unknown;
+    code?: string;
+}
+export declare class LiknossError extends Error {
+    readonly cause?: unknown;
+    readonly code?: string;
+    constructor(message: string, options?: LiknossErrorOptions);
+}
+export declare class LiknossConfigurationError extends LiknossError {
+}
+export declare class LiknossNetworkError extends LiknossError {
+    readonly endpoint: string;
+    readonly method: string;
+    constructor(message: string, details: {
+        cause?: unknown;
+        endpoint: string;
+        method: string;
+    });
+}
+export declare class LiknossHttpError extends LiknossError {
+    readonly endpoint: string;
+    readonly method: string;
+    readonly responseBody?: string;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(message: string, details: {
+        endpoint: string;
+        method: string;
+        responseBody?: string;
+        status: number;
+        statusText: string;
+    });
+}
+export declare class LiknossResponseParseError extends LiknossError {
+    readonly endpoint: string;
+    readonly method: string;
+    readonly rawBody: string;
+    readonly status: number;
+    constructor(message: string, details: {
+        cause?: unknown;
+        endpoint: string;
+        method: string;
+        rawBody: string;
+        status: number;
+    });
+}
+export declare class LiknossApiError<TPayload = unknown> extends LiknossError {
+    readonly issues: LiknossWarning[];
+    readonly meta: LiknossResponseMeta;
+    readonly payload: TPayload;
+    constructor(message: string, details: {
+        issues: LiknossWarning[];
+        meta: LiknossResponseMeta;
+        payload: TPayload;
+    });
+}
+export {};

package/build/liknoss-client/core/methods.d.ts

@@ -0,0 +1,4 @@
+import type { PathsWithMethod } from "./openapi";
+import type { LiknossGetMethod, LiknossPostMethod, LiknossTransport } from "./types";
+export declare function createGetMethod<Path extends PathsWithMethod<"get">>(transport: LiknossTransport, path: Path): LiknossGetMethod<Path>;
+export declare function createPostMethod<Path extends PathsWithMethod<"post">>(transport: LiknossTransport, path: Path): LiknossPostMethod<Path>;

package/build/liknoss-client/core/normalize.d.ts

@@ -0,0 +1,9 @@
+import type { LiknossApiPayloadShape, LiknossResponseMeta, LiknossWarning } from "./types";
+export declare function isLiknossApiPayload(value: unknown): value is LiknossApiPayloadShape;
+export declare function hasSevereLiknossApiError(value: unknown): boolean;
+export declare function normalizeLiknossWarnings(value: unknown): LiknossWarning[];
+export declare function createLiknossResponseMeta(value: unknown, details: {
+    endpoint: string;
+    method: string;
+    status: number;
+}): LiknossResponseMeta;

package/build/liknoss-client/core/openapi.d.ts

@@ -0,0 +1,61 @@
+import type { paths } from "../generated/openapi";
+export type LiknossHttpMethod = "get" | "post";
+export type PathsWithMethod<Method extends LiknossHttpMethod> = {
+    [Path in keyof paths]: Method extends keyof paths[Path] ? paths[Path][Method] extends undefined ? never : Path : never;
+}[keyof paths];
+export type OperationAt<Path extends PathsWithMethod<Method>, Method extends LiknossHttpMethod> = NonNullable<paths[Path][Method]>;
+type ParametersOf<Operation> = Operation extends {
+    parameters: infer Parameters;
+} ? Parameters : never;
+export type QueryOf<Operation> = ParametersOf<Operation> extends {
+    query?: infer Query;
+} ? Query : never;
+export type PathParamsOf<Operation> = ParametersOf<Operation> extends {
+    path?: infer PathParams;
+} ? PathParams : never;
+export type JsonBodyOf<Operation> = Operation extends {
+    requestBody: {
+        content: {
+            "application/json": infer Body;
+        };
+    };
+} ? Body : Operation extends {
+    requestBody?: {
+        content: {
+            "application/json": infer Body;
+        };
+    };
+} ? Body : never;
+export type BodyArgOf<Operation> = [JsonBodyOf<Operation>] extends [never] ? {
+    body?: never;
+} : Operation extends {
+    requestBody: {
+        content: {
+            "application/json": infer Body;
+        };
+    };
+} ? {
+    body: Body;
+} : Operation extends {
+    requestBody?: {
+        content: {
+            "application/json": infer Body;
+        };
+    };
+} ? {
+    body?: Body;
+} : {
+    body?: never;
+};
+type ResponseBodyOf<Response> = Response extends {
+    content: {
+        "application/json": infer Body;
+    };
+} ? Body : never;
+type ResponsesOf<Operation> = Operation extends {
+    responses: infer Responses;
+} ? Responses : never;
+export type SuccessBodyOf<Operation> = ResponsesOf<Operation> extends {
+    200: infer Success;
+} ? ResponseBodyOf<Success> : never;
+export {};

package/build/liknoss-client/core/request.d.ts

@@ -0,0 +1,2 @@
+import type { LiknossClientOptions, LiknossTransport } from "./types";
+export declare function createLiknossTransport(options?: LiknossClientOptions): LiknossTransport;

package/build/liknoss-client/core/types.d.ts

@@ -0,0 +1,66 @@
+import type { components } from "../generated/openapi";
+import type { BodyArgOf, LiknossHttpMethod, OperationAt, PathParamsOf, PathsWithMethod, QueryOf, SuccessBodyOf } from "./openapi";
+export type LiknossApiErrorDetail = components["schemas"]["ErrorDetail"];
+export type LiknossBookingStatus = components["schemas"]["BookingStatusPerCompany"];
+export interface LiknossClientOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    defaultHeaders?: HeadersInit;
+    fetch?: typeof fetch;
+}
+export interface LiknossRequestOptions {
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
+export interface LiknossWarning {
+    code?: string;
+    company?: string;
+    description: string;
+    severity?: string;
+    source: "bookingStatus" | "perCompanyErrorDetails";
+}
+export interface LiknossResponseMeta {
+    abbreviation?: string;
+    code?: string;
+    endpoint: string;
+    message?: string;
+    method: Uppercase<LiknossHttpMethod>;
+    requestId?: string;
+    responseCode?: string;
+    responseDescription?: string;
+    status: number;
+}
+export interface LiknossResult<TData> {
+    data: TData;
+    meta: LiknossResponseMeta;
+    warnings: LiknossWarning[];
+}
+export interface LiknossApiPayloadShape {
+    abbreviation?: string;
+    bookingStatusesPerCompany?: LiknossBookingStatus[];
+    code?: string;
+    message?: string;
+    perCompanyErrorDetails?: Record<string, LiknossApiErrorDetail[]>;
+    requestId?: string;
+    responseCode?: string;
+    responseDesciption?: string;
+    severeError?: boolean;
+}
+type BaseMethodArgs<Path extends PathsWithMethod<Method>, Method extends LiknossHttpMethod> = LiknossRequestOptions & BodyArgOf<OperationAt<Path, Method>> & {
+    pathParams?: PathParamsOf<OperationAt<Path, Method>>;
+    query?: QueryOf<OperationAt<Path, Method>>;
+};
+export type LiknossMethodArgs<Path extends PathsWithMethod<Method>, Method extends LiknossHttpMethod> = BaseMethodArgs<Path, Method>;
+export interface LiknossRequestConfig<Path extends PathsWithMethod<Method>, Method extends LiknossHttpMethod> extends LiknossRequestOptions {
+    body?: BodyArgOf<OperationAt<Path, Method>>["body"];
+    method: Uppercase<Method>;
+    path: Path;
+    pathParams?: PathParamsOf<OperationAt<Path, Method>>;
+    query?: QueryOf<OperationAt<Path, Method>>;
+}
+export interface LiknossTransport {
+    request<Path extends PathsWithMethod<Method>, Method extends LiknossHttpMethod>(config: LiknossRequestConfig<Path, Method>): Promise<LiknossResult<SuccessBodyOf<OperationAt<Path, Method>>>>;
+}
+export type LiknossGetMethod<Path extends PathsWithMethod<"get">> = (config?: LiknossMethodArgs<Path, "get">) => Promise<LiknossResult<SuccessBodyOf<OperationAt<Path, "get">>>>;
+export type LiknossPostMethod<Path extends PathsWithMethod<"post">> = (config: LiknossMethodArgs<Path, "post">) => Promise<LiknossResult<SuccessBodyOf<OperationAt<Path, "post">>>>;
+export {};