@unchainedshop/ticketing 4.6.1 → 4.6.2

package/lib/routes.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@unchainedshop/api';
+import type { TicketingAPI } from './index.ts';
+export declare function printTicketsHandler(request: Request, context: Context): Promise<Response>;
+export declare function googleWalletHandler(request: Request, context: TicketingAPI & {
+    params: Record<string, string>;
+}): Promise<Response>;
+export declare function appleWalletHandler(request: Request, context: TicketingAPI & {
+    params: Record<string, string>;
+}): Promise<Response>;
+export declare const ticketingRoutes: ({
+    path: string;
+    handler: typeof printTicketsHandler;
+} | {
+    path: string;
+    handler: typeof googleWalletHandler;
+})[];

package/lib/routes.js

@@ -0,0 +1,288 @@
+import { Readable } from 'node:stream';
+import { checkAction } from '@unchainedshop/api/lib/acl.js';
+import { actions } from '@unchainedshop/api/lib/roles/index.js';
+import { RendererTypes, getRenderer } from "./template-registry.js";
+import { createLogger } from '@unchainedshop/logger';
+import { getFileAdapter } from '@unchainedshop/core';
+const logger = createLogger('unchained:ticketing');
+const { APPLE_WALLET_WEBSERVICE_PATH = '/rest/apple-wallet', GOOGLE_WALLET_WEBSERVICE_PATH = '/rest/google-wallet', UNCHAINED_PDF_PRINT_HANDLER_PATH = '/rest/print_tickets', } = process.env;
+const isAuthenticationTokenCorrect = (authHeader, authenticationToken) => {
+    const expectedAuthorizationValue = `ApplePass ${authenticationToken}`;
+    return authHeader === expectedAuthorizationValue;
+};
+export async function printTicketsHandler(request, context) {
+    const url = new URL(request.url);
+    const variant = url.searchParams.get('variant');
+    const orderId = url.searchParams.get('orderId');
+    const otp = url.searchParams.get('otp');
+    try {
+        if (!orderId || !otp) {
+            throw new Error('Missing required query parameters: orderId and otp');
+        }
+        await checkAction(context, actions.viewOrder, [undefined, { orderId, otp }]);
+        const render = getRenderer(RendererTypes.ORDER_PDF);
+        const pdfStream = await render({ orderId, variant: variant }, context);
+        const webStream = Readable.toWeb(pdfStream);
+        return new Response(webStream, {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/pdf',
+            },
+        });
+    }
+    catch (error) {
+        logger.error(error);
+        return new Response(null, { status: 403 });
+    }
+}
+export async function googleWalletHandler(request, context) {
+    const { modules } = context;
+    const { tokenId } = context.params;
+    try {
+        if (!tokenId) {
+            return new Response(JSON.stringify({ error: 'Token ID required' }), {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const token = await modules.warehousing.findToken({ tokenId });
+        if (!token) {
+            return new Response(JSON.stringify({ error: 'Token not found' }), {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const url = new URL(request.url);
+        const hash = url.searchParams.get('hash');
+        const correctHash = await modules.warehousing.buildAccessKeyForToken(tokenId);
+        if (!hash || hash !== correctHash) {
+            return new Response(JSON.stringify({ error: 'Token hash invalid for current owner' }), {
+                status: 403,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const passLink = await modules.passes.upsertGoogleWalletPass(token, context);
+        return new Response(JSON.stringify({ passLink }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    catch (e) {
+        logger.error(e);
+        return new Response(JSON.stringify({ error: 'Internal server error' }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}
+export async function appleWalletHandler(request, context) {
+    const { modules } = context;
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    logger.info(`${pathname} (${JSON.stringify(Object.fromEntries(url.searchParams))})`);
+    if (pathname.includes('/download/')) {
+        try {
+            const pathParts = pathname.split('/');
+            const passFileName = pathParts[pathParts.length - 1];
+            const [tokenId] = passFileName.split('.pkpass');
+            if (!tokenId) {
+                return new Response(null, { status: 404 });
+            }
+            const token = await modules.warehousing.findToken({ tokenId });
+            if (!token) {
+                return new Response(JSON.stringify({ error: 'Token not found' }), {
+                    status: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            const hash = url.searchParams.get('hash');
+            const correctHash = await modules.warehousing.buildAccessKeyForToken(tokenId);
+            if (!hash || hash !== correctHash) {
+                return new Response(JSON.stringify({ error: 'Token hash invalid for current owner' }), {
+                    status: 403,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            const passFile = await modules.passes.upsertAppleWalletPass(token, context);
+            const fileUploadAdapter = getFileAdapter();
+            const signedUrl = await fileUploadAdapter.createDownloadURL(passFile);
+            const downloadUrl = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
+            if (!downloadUrl) {
+                return new Response(JSON.stringify({
+                    success: false,
+                    message: 'Could not create download URL',
+                    name: 'URL_SIGNING_FAILED',
+                }), {
+                    status: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            const response = await fetch(downloadUrl);
+            const data = await response.arrayBuffer();
+            return new Response(data, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/vnd.apple.pkpass',
+                    'Content-Disposition': `attachment; filename=${tokenId}.pkpass`,
+                },
+            });
+        }
+        catch (e) {
+            logger.error(e);
+            return new Response(null, { status: 500 });
+        }
+    }
+    const pathParts = pathname.split('/').filter(Boolean);
+    const [, , endpoint, ...pathComponents] = pathParts;
+    if (endpoint === 'devices') {
+        if (request.method === 'POST') {
+            const [deviceLibraryIdentifier, , passTypeIdentifier, serialNumber] = pathComponents;
+            try {
+                const body = await request.json();
+                const { pushToken } = body;
+                const pass = await modules.passes.findAppleWalletPass(passTypeIdentifier, serialNumber);
+                if (!pass) {
+                    return new Response(null, { status: 404 });
+                }
+                const authToken = pass.meta?.rawData?._id || pass.meta?.rawData?.tokenId;
+                if (!isAuthenticationTokenCorrect(request.headers.get('authorization'), authToken)) {
+                    return new Response(null, { status: 401 });
+                }
+                const newRegistration = await modules.passes.registerDeviceForAppleWalletPass(passTypeIdentifier, serialNumber, {
+                    deviceLibraryIdentifier,
+                    pushToken,
+                });
+                return new Response(null, { status: newRegistration ? 201 : 200 });
+            }
+            catch (e) {
+                logger.error(e);
+                return new Response(null, { status: 500 });
+            }
+        }
+        else if (request.method === 'GET') {
+            const [deviceLibraryIdentifier, , passTypeIdentifier] = pathComponents;
+            const passesUpdatedSinceParam = url.searchParams.get('passesUpdatedSince');
+            const passesUpdatedSince = passesUpdatedSinceParam ? new Date(passesUpdatedSinceParam) : undefined;
+            try {
+                const passes = await modules.passes.findUpdatedAppleWalletPasses(passTypeIdentifier, deviceLibraryIdentifier, passesUpdatedSince);
+                const serialNumbers = passes.map((t) => t.meta?.serialNumber).filter(Boolean);
+                if (serialNumbers?.length) {
+                    return new Response(JSON.stringify({
+                        serialNumbers,
+                        lastUpdated: new Date(),
+                    }), {
+                        status: 200,
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+                return new Response(null, { status: 204 });
+            }
+            catch (e) {
+                logger.error(e);
+                return new Response(null, { status: 500 });
+            }
+        }
+        else if (request.method === 'DELETE') {
+            const [deviceLibraryIdentifier, , passTypeIdentifier, serialNumber] = pathComponents;
+            try {
+                const pass = await modules.passes.findAppleWalletPass(passTypeIdentifier, serialNumber);
+                if (!pass) {
+                    return new Response(null, { status: 404 });
+                }
+                const authToken = pass.meta?.rawData?._id || pass.meta?.rawData?.tokenId;
+                if (!isAuthenticationTokenCorrect(request.headers.get('authorization'), authToken)) {
+                    return new Response(null, { status: 401 });
+                }
+                await modules.passes.unregisterDeviceForAppleWalletPass(passTypeIdentifier, serialNumber, deviceLibraryIdentifier);
+                return new Response(null, { status: 200 });
+            }
+            catch (e) {
+                logger.error(e);
+                return new Response(null, { status: 500 });
+            }
+        }
+    }
+    else if (endpoint === 'log') {
+        try {
+            const body = await request.json();
+            const { logs } = body;
+            logs?.forEach((log) => {
+                if (typeof log === 'string') {
+                    logger.info(log);
+                }
+            });
+            return new Response(null, { status: 200 });
+        }
+        catch (e) {
+            logger.error(e);
+            return new Response(null, { status: 500 });
+        }
+    }
+    else if (endpoint === 'passes') {
+        if (request.method === 'GET') {
+            const [passTypeIdentifier, serialNumber] = pathComponents;
+            try {
+                const pass = await modules.passes.findAppleWalletPass(passTypeIdentifier, serialNumber);
+                if (!pass) {
+                    return new Response(null, { status: 404 });
+                }
+                const authToken = pass.meta?.rawData?._id || pass.meta?.rawData?.tokenId;
+                if (!isAuthenticationTokenCorrect(request.headers.get('authorization'), authToken)) {
+                    return new Response(null, { status: 401 });
+                }
+                const { updated, created } = pass;
+                const lastModifiedDate = new Date(updated || created);
+                lastModifiedDate.setMilliseconds(0);
+                const ifModifiedSinceHeader = request.headers.get('if-modified-since');
+                if (ifModifiedSinceHeader) {
+                    const ifModifiedSinceDate = new Date(ifModifiedSinceHeader);
+                    ifModifiedSinceDate.setMilliseconds(0);
+                    if (ifModifiedSinceDate.getTime() >= lastModifiedDate.getTime()) {
+                        return new Response(null, { status: 304 });
+                    }
+                }
+                const fileUploadAdapter = getFileAdapter();
+                const signedUrl = await fileUploadAdapter.createDownloadURL(pass);
+                const downloadUrl = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
+                if (!downloadUrl) {
+                    return new Response(JSON.stringify({
+                        success: false,
+                        message: 'Could not create download URL',
+                        name: 'URL_SIGNING_FAILED',
+                    }), {
+                        status: 500,
+                        headers: { 'Content-Type': 'application/json' },
+                    });
+                }
+                const result = await fetch(downloadUrl);
+                const data = await result.arrayBuffer();
+                return new Response(data, {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'application/vnd.apple.pkpass',
+                        'Last-Modified': lastModifiedDate.toUTCString(),
+                    },
+                });
+            }
+            catch (e) {
+                logger.error(e);
+                return new Response(null, { status: 500 });
+            }
+        }
+    }
+    return new Response(null, { status: 404 });
+}
+export const ticketingRoutes = [
+    {
+        path: UNCHAINED_PDF_PRINT_HANDLER_PATH,
+        handler: printTicketsHandler,
+    },
+    {
+        path: `${GOOGLE_WALLET_WEBSERVICE_PATH}/download/:tokenId`,
+        handler: googleWalletHandler,
+    },
+    {
+        path: `${APPLE_WALLET_WEBSERVICE_PATH}/*`,
+        handler: appleWalletHandler,
+    },
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/ticketing",
   "description": "Event ticketing extension for the Unchained Engine with PDF and wallet pass support",
-  "version": "4.6.1",
+  "version": "4.6.2",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "type": "module",