@paakd/api 0.0.1 → 0.0.2

package/dist/src/registration.d.ts

@@ -0,0 +1,60 @@
+import { Code, ConnectError } from '@connectrpc/connect';
+import type { RegisterRequest } from '../gen/src/proto/auth/v1/entities/auth_pb';
+export interface RegisterCustomerRequest {
+    body: Omit<RegisterRequest, '$typeName'>;
+    headers: Record<string, string | null>;
+}
+interface VerifyEmailRequest {
+    body: {
+        email: string;
+        locale: string;
+        idempotencyKey?: string;
+    };
+    headers: Record<string, string | null>;
+}
+interface ValidateOTPRequest {
+    body: {
+        email: string;
+        otp: string;
+    };
+    headers: Record<string, string | null>;
+}
+export declare function verifyEmail({ body: { email, idempotencyKey, locale }, headers, }: VerifyEmailRequest): Promise<ConnectError | {
+    value: import("../gen/src/proto/auth/v1/entities/auth_pb").VerifyEmailResponse;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+export declare function validateOTP({ body: { email, otp }, headers, }: ValidateOTPRequest): Promise<ConnectError | {
+    value: import("../gen/src/proto/auth/v1/entities/auth_pb").ValidateOTPResponse;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+export declare function registerCustomer({ body: val, headers, }: RegisterCustomerRequest): Promise<ConnectError | {
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+}>;
+export {};
+//# sourceMappingURL=registration.d.ts.map

package/dist/src/registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.d.ts","sourceRoot":"","sources":["../../src/registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,YAAY,EAAgB,MAAM,qBAAqB,CAAA;AAItE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAA;AAehF,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,CAAA;IACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,EAAE,MAAM,CAAA;QACd,cAAc,CAAC,EAAE,MAAM,CAAA;KACxB,CAAA;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,EAAE,MAAM,CAAA;KACZ,CAAA;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,wBAAsB,WAAW,CAAC,EAChC,IAAI,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,EACvC,OAAO,GACR,EAAE,kBAAkB;;;;;;;;;;;;GAyCpB;AAED,wBAAsB,WAAW,CAAC,EAChC,IAAI,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EACpB,OAAO,GACR,EAAE,kBAAkB;;;;;;;;;;;;GAwCpB;AAED,wBAAsB,gBAAgB,CAAC,EACrC,IAAI,EAAE,GAAG,EACT,OAAO,GACR,EAAE,uBAAuB;;;;;;;;;;GAkCzB"}

package/dist/src/registration.js

@@ -0,0 +1,147 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyEmail = verifyEmail;
+exports.validateOTP = validateOTP;
+exports.registerCustomer = registerCustomer;
+const connect_1 = require("@connectrpc/connect");
+const connect_node_1 = require("@connectrpc/connect-node");
+const config_1 = require("@paakd/config");
+const service_pb_1 = require("../gen/src/proto/auth/v1/service_pb");
+const brotli_1 = require("./compressor/brotli");
+const interceptors_1 = require("./interceptors");
+const localeMap = {
+    'en-GB': 0,
+    'en-US': 1,
+    'nl-NL': 2,
+    'de-DE': 3,
+    en: 0,
+};
+function verifyEmail(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { email, idempotencyKey, locale }, headers, }) {
+        var _b;
+        const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl: checkoutConfig.enterpriseURL,
+            interceptors: [
+                (0, interceptors_1.createHeadersInterceptor)(headers),
+                (0, interceptors_1.createAuthenticationInterceptor)(checkoutConfig),
+            ],
+            acceptCompression: [brotli_1.brotliCompression],
+            sendCompression: brotli_1.brotliCompression,
+        });
+        const auth = (0, connect_1.createClient)(service_pb_1.AuthService, transport);
+        try {
+            const value = yield auth.verifyEmail({
+                email,
+                locale: (_b = localeMap[locale]) !== null && _b !== void 0 ? _b : 0,
+                idempotencyKey,
+            });
+            return {
+                value,
+                status: 'success',
+            };
+        }
+        catch (err) {
+            if (err instanceof connect_1.ConnectError) {
+                return {
+                    code: err.code,
+                    rawMessage: err.rawMessage,
+                    message: err.rawMessage,
+                    status: 'failed',
+                };
+            }
+            return {
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred while verifying the email.',
+                message: 'An unexpected error occurred while verifying the email.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function validateOTP(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { email, otp }, headers, }) {
+        const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl: checkoutConfig.enterpriseURL,
+            interceptors: [
+                (0, interceptors_1.createHeadersInterceptor)(headers),
+                (0, interceptors_1.createAuthenticationInterceptor)(checkoutConfig),
+            ],
+            acceptCompression: [brotli_1.brotliCompression],
+            sendCompression: brotli_1.brotliCompression,
+        });
+        const auth = (0, connect_1.createClient)(service_pb_1.AuthService, transport);
+        try {
+            const value = yield auth.validateOTP({
+                email,
+                otp,
+            });
+            return {
+                value,
+                status: 'success',
+            };
+        }
+        catch (err) {
+            if (err instanceof connect_1.ConnectError) {
+                return {
+                    code: err.code,
+                    rawMessage: err.rawMessage,
+                    message: err.rawMessage,
+                    status: 'failed',
+                };
+            }
+            return {
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred while validating the OTP.',
+                message: 'An unexpected error occurred while validating the OTP.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function registerCustomer(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: val, headers, }) {
+        const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl: checkoutConfig.enterpriseURL,
+            interceptors: [
+                (0, interceptors_1.createHeadersInterceptor)(headers),
+                (0, interceptors_1.createAuthenticationInterceptor)(checkoutConfig),
+            ],
+            acceptCompression: [brotli_1.brotliCompression],
+            sendCompression: brotli_1.brotliCompression,
+        });
+        const auth = (0, connect_1.createClient)(service_pb_1.AuthService, transport);
+        try {
+            yield auth.register(val);
+            return {
+                status: 'success',
+            };
+        }
+        catch (err) {
+            if (err instanceof connect_1.ConnectError) {
+                return {
+                    code: err.code,
+                    rawMessage: err.rawMessage,
+                    message: err.rawMessage,
+                    status: 'failed',
+                };
+            }
+            return {
+                code: connect_1.Code.Internal,
+                message: 'An unexpected error occurred during registration.',
+                status: 'failed',
+            };
+        }
+    });
+}

package/dist/src/test-utils.d.ts

@@ -0,0 +1,87 @@
+import { ConnectError } from '@connectrpc/connect';
+import type { Checkout } from '@paakd/config';
+import { type MockedFunction } from 'vitest';
+export type { Checkout, MockedFunction };
+/**
+ * Common mock client interface for service tests
+ */
+export type MockServiceClient = Record<string, MockedFunction<(...args: unknown[]) => unknown>>;
+/**
+ * Mock Transport type
+ */
+export type Transport = any;
+/**
+ * Base test context for API service tests
+ */
+export interface BaseTestContext {
+    client: MockServiceClient;
+    config: Checkout;
+    interceptors: Record<string, MockedFunction<(...args: unknown[]) => unknown>>;
+    transport: Transport;
+}
+/**
+ * Creates a mock ConnectError with proper prototype chain
+ * This ensures that instanceof ConnectError checks work correctly
+ */
+export declare function createMockConnectError(code: number, rawMessage: string, message: string): ConnectError;
+/**
+ * Creates a default mock configuration used across API services
+ */
+export declare function createMockConfig(): Checkout;
+/**
+ * Creates a default mock interceptors object
+ */
+export declare function createMockInterceptors(): Record<string, MockedFunction<(...args: unknown[]) => unknown>>;
+/**
+ * Creates a mock gRPC transport
+ */
+export declare function createMockTransport(): Transport;
+/**
+ * Helper to setup common mocks for API service tests
+ * Returns objects ready to be used with setupService functions
+ */
+export declare function setupCommonMocks(): {
+    config: Checkout;
+    interceptors: Record<string, MockedFunction<(...args: unknown[]) => unknown>>;
+    transport: Transport;
+};
+/**
+ * Clears all Vitest mocks - useful for test isolation
+ */
+export declare function clearAllMocks(): void;
+/**
+ * Common error scenarios for testing
+ */
+export declare const COMMON_ERROR_SCENARIOS: {
+    readonly INVALID_CREDENTIALS: {
+        readonly code: 16;
+        readonly message: "UNAUTHENTICATED";
+        readonly rawMessage: "Invalid credentials provided";
+    };
+    readonly NOT_FOUND: {
+        readonly code: 5;
+        readonly message: "NOT_FOUND";
+        readonly rawMessage: "Resource not found";
+    };
+    readonly PERMISSION_DENIED: {
+        readonly code: 7;
+        readonly message: "PERMISSION_DENIED";
+        readonly rawMessage: "Permission denied";
+    };
+    readonly INTERNAL_ERROR: {
+        readonly code: 13;
+        readonly message: "INTERNAL";
+        readonly rawMessage: "Internal server error";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly code: 14;
+        readonly message: "UNAVAILABLE";
+        readonly rawMessage: "Service temporarily unavailable";
+    };
+    readonly INVALID_ARGUMENT: {
+        readonly code: 3;
+        readonly message: "INVALID_ARGUMENT";
+        readonly rawMessage: "Invalid argument provided";
+    };
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/src/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAM,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAA;AAGhD,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAA;AAExC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CACpC,MAAM,EACN,cAAc,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAChD,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,GAAG,CAAA;AAE3B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,iBAAiB,CAAA;IACzB,MAAM,EAAE,QAAQ,CAAA;IAChB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,CAAA;IAC7E,SAAS,EAAE,SAAS,CAAA;CACrB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,YAAY,CAUd;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CA4B3C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAC9C,MAAM,EACN,cAAc,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAChD,CAgBA;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,CAE/C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI;IAClC,MAAM,EAAE,QAAQ,CAAA;IAChB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,CAAA;IAC7E,SAAS,EAAE,SAAS,CAAA;CACrB,CAUA;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BzB,CAAA"}

package/dist/src/test-utils.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMON_ERROR_SCENARIOS = void 0;
+exports.createMockConnectError = createMockConnectError;
+exports.createMockConfig = createMockConfig;
+exports.createMockInterceptors = createMockInterceptors;
+exports.createMockTransport = createMockTransport;
+exports.setupCommonMocks = setupCommonMocks;
+exports.clearAllMocks = clearAllMocks;
+const connect_1 = require("@connectrpc/connect");
+const vitest_1 = require("vitest");
+/**
+ * Creates a mock ConnectError with proper prototype chain
+ * This ensures that instanceof ConnectError checks work correctly
+ */
+function createMockConnectError(code, rawMessage, message) {
+    const error = {
+        code,
+        rawMessage,
+        message,
+        name: 'ConnectError',
+    };
+    Object.setPrototypeOf(error, connect_1.ConnectError.prototype);
+    return error;
+}
+/**
+ * Creates a default mock configuration used across API services
+ */
+function createMockConfig() {
+    return {
+        hostname: 'example.com',
+        cmsRemoteURL: 'https://cms.example.com',
+        enterpriseRemoteURL: 'https://enterprise.example.com',
+        cmsURL: 'https://cms-local.example.com',
+        enterpriseURL: 'https://enterprise.example.com',
+        secureCookiePassword: 'secure-cookie-password',
+        forestAPIKey: 'forest-api-key',
+        saleChannelAccessKey: 'channel-access',
+        salesChannelAPISecret: 'channel-secret',
+        storeAccessKey: 'store-access',
+        storeAPISecret: 'store-secret',
+        isProduction: false,
+        posthogKey: 'posthog-key',
+        posthogDomain: 'posthog.example.com',
+        posthogHost: 'posthog.example.com',
+        assetsPath: '/assets',
+        assetsDomain: 'assets.example.com',
+        turnstileKey: 'turnstile-key',
+        turnstileSecret: 'turnstile-secret',
+        redis: {
+            user: 'redis-user',
+            host: 'localhost',
+            password: 'redis-password',
+            port: 6379,
+        },
+    };
+}
+/**
+ * Creates a default mock interceptors object
+ */
+function createMockInterceptors() {
+    return {
+        headers: vitest_1.vi
+            .fn()
+            .mockReturnValue(Symbol('headers-interceptor')),
+        auth: vitest_1.vi.fn().mockReturnValue(Symbol('auth-interceptor')),
+        customer: vitest_1.vi
+            .fn()
+            .mockReturnValue(Symbol('customer-interceptor')),
+    };
+}
+/**
+ * Creates a mock gRPC transport
+ */
+function createMockTransport() {
+    return {};
+}
+/**
+ * Helper to setup common mocks for API service tests
+ * Returns objects ready to be used with setupService functions
+ */
+function setupCommonMocks() {
+    const config = createMockConfig();
+    const interceptors = createMockInterceptors();
+    const transport = createMockTransport();
+    return {
+        config,
+        interceptors,
+        transport,
+    };
+}
+/**
+ * Clears all Vitest mocks - useful for test isolation
+ */
+function clearAllMocks() {
+    vitest_1.vi.clearAllMocks();
+}
+/**
+ * Common error scenarios for testing
+ */
+exports.COMMON_ERROR_SCENARIOS = {
+    INVALID_CREDENTIALS: {
+        code: 16,
+        message: 'UNAUTHENTICATED',
+        rawMessage: 'Invalid credentials provided',
+    },
+    NOT_FOUND: {
+        code: 5,
+        message: 'NOT_FOUND',
+        rawMessage: 'Resource not found',
+    },
+    PERMISSION_DENIED: {
+        code: 7,
+        message: 'PERMISSION_DENIED',
+        rawMessage: 'Permission denied',
+    },
+    INTERNAL_ERROR: {
+        code: 13,
+        message: 'INTERNAL',
+        rawMessage: 'Internal server error',
+    },
+    SERVICE_UNAVAILABLE: {
+        code: 14,
+        message: 'UNAVAILABLE',
+        rawMessage: 'Service temporarily unavailable',
+    },
+    INVALID_ARGUMENT: {
+        code: 3,
+        message: 'INVALID_ARGUMENT',
+        rawMessage: 'Invalid argument provided',
+    },
+};