@unchainedshop/ticketing 2.10.0

package/lib/template-registry.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Context } from '@unchainedshop/types/api.js';
+import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { TokenSurrogate } from '@unchainedshop/types/warehousing.js';
+export type PDFRenderer = ({ orderId, variant, }: {
+    orderId: string;
+    variant?: string;
+}, context: Context) => Promise<NodeJS.ReadableStream>;
+export type PassRenderer = (token: TokenSurrogate, context: UnchainedCore) => Promise<{
+    asURL?: () => Promise<string>;
+    asBuffer?: () => Promise<Buffer>;
+    serialNumber?: string;
+    passTypeIdentifier?: string;
+}>;
+export declare enum RendererTypes {
+    GOOGLE_WALLET = "google-wallet",
+    APPLE_WALLET = "apple-wallet",
+    ORDER_PDF = "order"
+}
+export declare const renderers: Map<string, PDFRenderer | PassRenderer>;
+export type RegisterRendererFn = ((type: RendererTypes.ORDER_PDF, renderer: PDFRenderer) => void) & ((type: RendererTypes.GOOGLE_WALLET | RendererTypes.APPLE_WALLET, renderer: PassRenderer) => void);
+export declare const registerRenderer: RegisterRendererFn;
+export type GetRendererFn = ((type: RendererTypes.ORDER_PDF) => PDFRenderer) & ((type: RendererTypes.GOOGLE_WALLET | RendererTypes.APPLE_WALLET) => PassRenderer);
+export declare const getRenderer: GetRendererFn;

package/lib/template-registry.js

@@ -0,0 +1,14 @@
+export var RendererTypes;
+(function (RendererTypes) {
+    RendererTypes["GOOGLE_WALLET"] = "google-wallet";
+    RendererTypes["APPLE_WALLET"] = "apple-wallet";
+    RendererTypes["ORDER_PDF"] = "order";
+})(RendererTypes || (RendererTypes = {}));
+export const renderers = new Map();
+export const registerRenderer = function registerRenderer(type, renderer) {
+    renderers.set(type, renderer);
+};
+export const getRenderer = function getRenderer(type) {
+    return renderers.get(type);
+};
+//# sourceMappingURL=template-registry.js.map

package/lib/template-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-registry.js","sourceRoot":"","sources":["../src/template-registry.ts"],"names":[],"mappings":"AAyBA,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,gDAA+B,CAAA;IAC/B,8CAA6B,CAAA;IAC7B,oCAAmB,CAAA;AACrB,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAsC,CAAC;AAKvE,MAAM,CAAC,MAAM,gBAAgB,GAAuB,SAAS,gBAAgB,CAC3E,IAAmB,EACnB,QAAoC;IAEpC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAChC,CAAC,CAAC;AAKF,MAAM,CAAC,MAAM,WAAW,GAAkB,SAAS,WAAW,CAAC,IAAmB;IAChF,OAAO,SAAS,CAAC,GAAG,CAAC,IAAI,CAAQ,CAAC;AACpC,CAAC,CAAC"}

package/lib/types.d.ts

@@ -0,0 +1,7 @@
+import type { UnchainedCore } from '@unchainedshop/types/core.js';
+import type { TicketingModule } from './module.js';
+export type TicketingAPI = UnchainedCore & {
+    modules: {
+        passes: TicketingModule;
+    };
+};

package/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@unchainedshop/ticketing",
+  "version": "2.10.0",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js",
+    "./*": "./lib/*"
+  },
+  "typesVersions": {
+    "*": {
+      "mobile-tickets/*": [
+        "./lib/mobile-tickets/*"
+      ],
+      "pdf-tickets/*": [
+        "./lib/pdf-tickets/*"
+      ]
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf lib",
+    "build": "npm run clean && tsc",
+    "watch": "tsc -w",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unchainedshop/unchained.git"
+  },
+  "keywords": [
+    "unchained",
+    "ecommerce",
+    "core"
+  ],
+  "author": "Joël Meiller",
+  "license": "EUPL-1.2",
+  "bugs": {
+    "url": "https://github.com/unchainedshop/unchained/issues"
+  },
+  "homepage": "https://github.com/unchainedshop/unchained#readme",
+  "peerDependencies": {
+    "@hyperlink/node-apn": "^5.1.4",
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@unchainedshop/api": "^2.10.0",
+    "@unchainedshop/core-files": "^2.10.0",
+    "@unchainedshop/core-worker": "^2.10.0",
+    "@unchainedshop/events": "^2.10.0",
+    "@unchainedshop/logger": "^2.10.0",
+    "@unchainedshop/mongodb": "^2.10.0",
+    "@unchainedshop/types": "^2.10.0"
+  }
+}

package/readme.md

@@ -0,0 +1,93 @@
+# Unchained Ticketing Extension
+
+## Setup Example
+
+boot.js:
+```js
+import { modules, setupTicketing } from "@unchainedshop/ticketing";
+
+...
+  const app = express();
+
+  const httpServer = http.createServer(app);
+
+  const engine = await startPlatform({
+    modules,
+    options: {},
+  });
+
+  await engine.apolloGraphQLServer.start();
+
+  connectPlatformToExpress4(app, engine, { corsOrigins: [] });
+
+  // Unchained Ticketing Extension
+  setupTicketing(app, engine.unchainedAPI as TicketingAPI, {
+    renderOrderPDF,
+    createAppleWalletPass,
+    createGoogleWalletPass,
+  });
+...
+```
+
+
+renderOrderPDF.ts:
+```tsx
+import React from "react";
+import ReactPDF, { Document } from "@react-pdf/renderer";
+
+const TicketTemplate = ({ tickets }: { tickets: Array<any> }) => {
+  return (
+    <Document>
+      Hello World
+    </Document>
+  );
+};
+
+export default async (
+  { orderId, variant }: { orderId: string },
+  { modules },
+) => {
+  const order = await modules.orders.findOrder({ orderId });
+  ...
+  const pdfStream = await ReactPDF.renderToStream(
+    <TicketTemplate tickets={tickets} />,
+  );
+  return pdfStream;
+};
+```
+
+createAppleWalletPass.ts:
+```ts
+import { UnchainedCore } from "@unchainedshop/types/core.js";
+import { Template, constants } from "@walletpass/pass-js";
+
+export default async (token, unchainedAPI: UnchainedCore) => {
+  const template = new Template(
+    "eventTicket",
+    ...
+  );
+  const pass = await template.createPass(...);
+  return pass;
+};
+```
+
+createGoogleWalletPass.ts:
+```ts
+import { UnchainedCore } from "@unchainedshop/types/core.js";
+import { google } from "googleapis";
+import jwt from "jsonwebtoken";
+
+export default async (token, unchainedAPI: UnchainedCore) => {
+  
+  const product = ...;
+
+  // upsert class
+
+  // upsert object
+
+  const asURL = async () =>
+    createJwtNewObjects(issuerId, product._id, token.chainTokenId);
+
+  return { asURL };
+};
+```

package/src/index.ts

@@ -0,0 +1,78 @@
+import express from 'express';
+import { subscribe } from '@unchainedshop/events';
+import { RawPayloadType } from '@unchainedshop/events/EventDirector.js';
+import { WorkerEventTypes } from '@unchainedshop/core-worker';
+import { Work } from '@unchainedshop/types/worker.js';
+import { RendererTypes, registerRenderer } from './template-registry.js';
+import loadAppleWalletHandler from './mobile-tickets/apple-webservice.js';
+import loadGoogleWalletHandler from './mobile-tickets/google-webservice.js';
+import loadPDFHandler from './pdf-tickets/print-webservice.js';
+import passes from './module.js';
+import type { TicketingAPI } from './types.js';
+
+export type { TicketingAPI, RendererTypes };
+
+export const ticketingModules = {
+  passes,
+};
+
+export function setupPDFTickets(
+  app: express.Express,
+  {
+    renderOrderPDF,
+  }: {
+    renderOrderPDF: any;
+  },
+) {
+  registerRenderer(RendererTypes.ORDER_PDF, renderOrderPDF);
+  loadPDFHandler(app);
+}
+
+export function setupMobileTickets(
+  app: express.Express,
+  {
+    createGoogleWalletPass,
+    createAppleWalletPass,
+  }: {
+    createGoogleWalletPass: any;
+    createAppleWalletPass: any;
+  },
+) {
+  registerRenderer(RendererTypes.GOOGLE_WALLET, createGoogleWalletPass);
+  registerRenderer(RendererTypes.APPLE_WALLET, createAppleWalletPass);
+
+  loadAppleWalletHandler(app);
+  loadGoogleWalletHandler(app);
+}
+
+export default function setupTicketing(
+  app: express.Express,
+  unchainedAPI: TicketingAPI,
+  {
+    renderOrderPDF,
+    createAppleWalletPass,
+    createGoogleWalletPass,
+  }: {
+    renderOrderPDF: any;
+    createAppleWalletPass: any;
+    createGoogleWalletPass: any;
+  },
+) {
+  setupPDFTickets(app, {
+    renderOrderPDF,
+  });
+  setupMobileTickets(app, {
+    createAppleWalletPass,
+    createGoogleWalletPass,
+  });
+
+  subscribe('TOKEN_INVALIDATED', async () => {
+    await unchainedAPI.modules.passes.invalidateAppleWalletPasses(unchainedAPI);
+  });
+
+  subscribe(WorkerEventTypes.FINISHED, async ({ payload: work }: RawPayloadType<Work>) => {
+    if ((work.type === 'EXPORT_TOKEN' || work.type === 'UPDATE_TOKEN_OWNERSHIP') && work.success) {
+      await unchainedAPI.modules.passes.invalidateAppleWalletPasses(unchainedAPI);
+    }
+  });
+}

package/src/mobile-tickets/apple-wallet.ts

@@ -0,0 +1,31 @@
+import apn from '@hyperlink/node-apn';
+import { Readable } from 'stream';
+
+export const pushToApplePushNotificationService = async (deviceTokens) => {
+  const apnProvider = new apn.Provider({
+    cert: process.env.PASS_CERTIFICATE_PATH,
+    key: process.env.PASS_CERTIFICATE_PATH,
+    passphrase: process.env.PASS_CERTIFICATE_SECRET,
+    production: true,
+  });
+
+  const note = new apn.Notification({});
+  return apnProvider.send(note, deviceTokens);
+};
+
+export const buildPassBinary = async (
+  chainTokenId: string,
+  pass: {
+    serialNumber: string;
+    asBuffer: () => Promise<Buffer>;
+  },
+) => {
+  const passBuffer = await pass.asBuffer();
+  const rawFile = {
+    _id: pass.serialNumber,
+    filename: `${chainTokenId}-${new Date().getTime()}.pkpass`,
+    createReadStream: () => Readable.from(passBuffer),
+    mimetype: 'application/vnd.apple.pkpass',
+  };
+  return rawFile;
+};

package/src/mobile-tickets/apple-webservice.ts

@@ -0,0 +1,245 @@
+import { createLogger } from '@unchainedshop/logger';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api/express/index.js';
+import express, { Request, Response } from 'express';
+import { TicketingAPI } from '../types.js';
+
+const logger = createLogger('unchained:apple-wallet-webservice');
+
+const { APPLE_WALLET_WEBSERVICE_PATH = '/rest/apple-wallet' } = process.env;
+
+const isAuthenticationTokenCorrect = (req, authenticationToken) => {
+  const expectedAuthorizationValue = `ApplePass ${authenticationToken}`;
+  return req.headers.authorization === expectedAuthorizationValue;
+};
+
+export const appleWalletHandler = async (
+  req: Request & { unchainedContext: TicketingAPI },
+  res: Response,
+) => {
+  const resolvedContext = req.unchainedContext;
+  const { modules } = resolvedContext;
+  logger.info(`${req.path} (${JSON.stringify(req.query)})`);
+
+  if (req.path.startsWith('/download/')) {
+    try {
+      const [, , passFileName] = req.path.split('/');
+      const [tokenId] = passFileName.split('.pkpass');
+
+      if (!tokenId) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+
+      const token = await modules.warehousing.findToken({
+        tokenId,
+      });
+
+      if (!token) {
+        res.writeHead(404);
+        res.end('Token not found');
+        return;
+      }
+
+      const { hash } = req.query;
+      const correctHash = await modules.warehousing.buildAccessKeyForToken(tokenId);
+      if (hash !== correctHash) {
+        res.writeHead(403);
+        res.end('Token hash invalid for current owner');
+        return;
+      }
+
+      const passFile = await modules.passes.upsertAppleWalletPass(token, resolvedContext);
+
+      const url = await modules.files.getUrl(passFile, {});
+      const response = await fetch(url);
+      const data = await response.arrayBuffer();
+      const uint8View = new Uint8Array(data);
+
+      res.status(200);
+      res.setHeader('Content-Type', 'application/vnd.apple.pkpass');
+      res.setHeader('Content-Disposition', `attachment; filename=${tokenId}.pkpass`);
+      res.end(uint8View);
+      return;
+    } catch (e) {
+      console.error(e);
+    }
+    res.writeHead(500);
+    res.end();
+    return;
+  }
+
+  const [, apiVersion, endpoint, ...pathComponents] = req.path.split("/"); /* eslint-disable-line */
+  if (endpoint === 'devices') {
+    if (req.method === 'POST') {
+      // Register Device
+      const [deviceLibraryIdentifier, , passTypeIdentifier, serialNumber] = pathComponents;
+      const { pushToken } = req.body;
+
+      const pass = await modules.passes.findAppleWalletPass(passTypeIdentifier, serialNumber);
+
+      if (pass) {
+        if (
+          !isAuthenticationTokenCorrect(
+            req,
+            (pass.meta.rawData as any)._id || (pass.meta.rawData as any).tokenId,
+          )
+        ) {
+          res.writeHead(401);
+          res.end();
+          return;
+        }
+
+        const newRegistration = await modules.passes.registerDeviceForAppleWalletPass(
+          passTypeIdentifier,
+          serialNumber,
+          {
+            deviceLibraryIdentifier,
+            pushToken,
+          },
+        );
+
+        if (!newRegistration) {
+          res.writeHead(200);
+          res.end();
+          return;
+        }
+
+        res.writeHead(201);
+        res.end();
+        return;
+      }
+    } else if (req.method === 'GET') {
+      // Get the List of Updatable Passes
+      const lastUpdated = new Date();
+      const [deviceLibraryIdentifier, , passTypeIdentifier] = pathComponents;
+      const passesUpdatedSince =
+        req.query?.passesUpdatedSince && new Date(req.query.passesUpdatedSince as string);
+
+      const passes = await modules.passes.findUpdatedAppleWalletPasses(
+        passTypeIdentifier,
+        deviceLibraryIdentifier,
+        passesUpdatedSince,
+      );
+      const serialNumbers = passes.map((t) => t.meta.serialNumber);
+
+      if (serialNumbers?.length) {
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+        });
+        res.write(
+          JSON.stringify({
+            serialNumbers,
+            lastUpdated,
+          }),
+        );
+        res.end();
+        return;
+      }
+
+      res.writeHead(204);
+      res.end();
+      return;
+    } else if (req.method === 'DELETE') {
+      // Unregister Device
+      const [deviceLibraryIdentifier, , passTypeIdentifier, serialNumber] = pathComponents;
+
+      const pass = await modules.passes.findAppleWalletPass(passTypeIdentifier, serialNumber);
+
+      if (pass) {
+        if (
+          !isAuthenticationTokenCorrect(
+            req,
+            (pass.meta.rawData as any)._id || (pass.meta.rawData as any).tokenId,
+          )
+        ) {
+          res.writeHead(401);
+          res.end();
+          return;
+        }
+
+        await modules.passes.unregisterDeviceForAppleWalletPass(
+          passTypeIdentifier,
+          serialNumber,
+          deviceLibraryIdentifier,
+        );
+
+        // Unregistered
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+    }
+  } else if (endpoint === 'log') {
+    // Log Mesage
+    const { logs } = req.body;
+    logs?.forEach((log) => {
+      if (typeof log === 'string') {
+        logger.info(log);
+      }
+    });
+    res.writeHead(200);
+    res.end();
+    return;
+  } else if (endpoint === 'passes') {
+    if (req.method === 'GET') {
+      // Get an updated Pass
+      const [passTypeIdentifier, serialNumber] = pathComponents;
+
+      const pass = await modules.passes.findAppleWalletPass(passTypeIdentifier, serialNumber);
+
+      if (pass) {
+        if (
+          !isAuthenticationTokenCorrect(
+            req,
+            (pass.meta.rawData as any)._id || (pass.meta.rawData as any).tokenId,
+          )
+        ) {
+          res.writeHead(401);
+          res.end();
+          return;
+        }
+
+        const { updated, created } = pass;
+
+        const lastModifiedDate = new Date(updated || created);
+        lastModifiedDate.setMilliseconds(0);
+
+        const ifModifiedSinceDate = new Date(req.header('if-modified-since'));
+        ifModifiedSinceDate.setMilliseconds(0);
+
+        if (ifModifiedSinceDate.getTime() >= lastModifiedDate.getTime()) {
+          res.writeHead(304);
+          res.end();
+          return;
+        }
+
+        const url = modules.files.getUrl(pass, {});
+        const result = await fetch(url);
+        const data = await result.arrayBuffer();
+        const uint8View = new Uint8Array(data);
+
+        res.writeHead(200, {
+          'Content-Type': 'application/vnd.apple.pkpass',
+          'Last-Modified': lastModifiedDate.toUTCString(),
+        });
+        res.end(uint8View);
+        return;
+      }
+    }
+  }
+
+  res.writeHead(404);
+  res.end();
+};
+
+export default function loadAppleWalletHandler(app) {
+  useMiddlewareWithCurrentContext(
+    app,
+    APPLE_WALLET_WEBSERVICE_PATH,
+    express.json({
+      type: 'application/json',
+    }),
+    appleWalletHandler,
+  );
+}

package/src/mobile-tickets/google-webservice.ts

@@ -0,0 +1,70 @@
+import { createLogger } from '@unchainedshop/logger';
+import { useMiddlewareWithCurrentContext } from '@unchainedshop/api/express/index.js';
+import express, { Request, Response } from 'express';
+import { TicketingAPI } from '../types.js';
+
+const logger = createLogger('unchained:google-wallet-webservice');
+
+const { GOOGLE_WALLET_WEBSERVICE_PATH = '/rest/google-wallet' } = process.env;
+
+export const googleWalletHandler = async (
+  req: Request & { unchainedContext: TicketingAPI },
+  res: Response,
+) => {
+  const resolvedContext = req.unchainedContext;
+  const { modules } = resolvedContext;
+  logger.info(`${req.path} (${JSON.stringify(req.query)})`);
+
+  if (req.path.startsWith('/download/')) {
+    try {
+      const [, , tokenId] = req.path.split('/');
+
+      if (!tokenId) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+
+      const token = await modules.warehousing.findToken({
+        tokenId,
+      });
+
+      if (!token) {
+        res.writeHead(404);
+        res.end('Token not found');
+        return;
+      }
+
+      const { hash } = req.query;
+      const correctHash = await modules.warehousing.buildAccessKeyForToken(tokenId);
+      if (hash !== correctHash) {
+        res.writeHead(403);
+        res.end('Token hash invalid for current owner');
+        return;
+      }
+
+      const pass = await modules.passes.upsertGoogleWalletPass(token, resolvedContext);
+
+      res.redirect(await pass.asURL());
+      return;
+    } catch (e) {
+      console.error(e);
+    }
+    res.writeHead(500);
+    res.end();
+    return;
+  }
+  res.writeHead(404);
+  res.end();
+};
+
+export default function loadGoogleWalletHandler(app) {
+  useMiddlewareWithCurrentContext(
+    app,
+    GOOGLE_WALLET_WEBSERVICE_PATH,
+    express.json({
+      type: 'application/json',
+    }),
+    googleWalletHandler,
+  );
+}