@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc2

package/src/express/createERCMetadataMiddleware.ts

@@ -1,8 +1,7 @@
-import { IncomingMessage } from 'http';
 import path from 'path';
 import { createLogger } from '@unchainedshop/logger';
-import { systemLocale } from '@unchainedshop/utils';
-import { Context } from '../types.js';
+import { Context } from '../context.js';
+import { Request, RequestHandler } from 'express';
 
 const logger = createLogger('unchained:erc-metadata');
 
@@ -18,46 +17,35 @@ const methodWrongHandler = (res) => () => {
   res.end();
 };
 
-export default async function ercMetadataMiddleware(
-  req: IncomingMessage & { unchainedContext: Context },
+const ercMetadataMiddleware: RequestHandler = async (
+  req: Request & { unchainedContext: Context },
   res,
-) {
+) => {
   try {
     if (req.method !== 'GET') {
       methodWrongHandler(res)();
       return;
     }
 
-    const context = req.unchainedContext;
+    const { services, localeContext } = req.unchainedContext;
     const url = new URL(req.url, process.env.ROOT_URL);
     const parsedPath = path.parse(url.pathname);
 
     if (parsedPath.ext !== '.json') throw new Error('Invalid ERC Metadata URI');
 
     const [, productId, localeOrTokenFilename, tokenFileName] = url.pathname.split('/');
+    const locale = tokenFileName ? new Intl.Locale(localeOrTokenFilename) : localeContext;
 
-    const locale = tokenFileName ? localeOrTokenFilename : systemLocale.language;
-    const chainTokenId = parsedPath.name;
-
-    const product = await context.modules.products.findProduct({
+    const ercMetadata = await services.warehousing.ercMetadata({
       productId,
+      locale,
+      chainTokenId: parsedPath.name,
     });
 
-    const [token] = await context.modules.warehousing.findTokens({
-      chainTokenId,
-      contractAddress: product?.tokenization?.contractAddress,
-    });
-
-    const ercMetadata = await context.modules.warehousing.tokenMetadata(
-      chainTokenId,
-      {
-        token,
-        product,
-        locale: new Intl.Locale(locale),
-        referenceDate: new Date(),
-      },
-      context,
-    );
+    if (!ercMetadata) {
+      methodWrongHandler(res);
+      return;
+    }
 
     const body = JSON.stringify(ercMetadata);
     res.writeHead(200, {
@@ -68,4 +56,6 @@ export default async function ercMetadataMiddleware(
   } catch (e) {
     errorHandler(res)(e);
   }
-}
+};
+
+export default ercMetadataMiddleware;

package/src/express/index.ts

@@ -1,11 +1,11 @@
-import type e from 'express';
+import e from 'express';
 import { getCurrentContextResolver } from '../context.js';
 import createBulkImportMiddleware from './createBulkImportMiddleware.js';
 import createERCMetadataMiddleware from './createERCMetadataMiddleware.js';
 import session from 'express-session';
 import MongoStore from 'connect-mongo';
+import { Passport } from 'passport';
 import { YogaServerInstance } from 'graphql-yoga';
-import setupPassport from './passport/setup.js';
 import { mongodb } from '@unchainedshop/mongodb';
 import { UnchainedCore } from '@unchainedshop/core';
 import { emit } from '@unchainedshop/events';
@@ -31,6 +31,8 @@ const {
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
+  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 
 const addContext = async function middlewareWithContext(
@@ -40,7 +42,7 @@ const addContext = async function middlewareWithContext(
 ) {
   try {
     const setHeader = (key, value) => res.setHeader(key, value);
-    const getHeader = (key) => req.headers[key];
+    const getHeader = (key) => req.headers[key] as string;
     const { remoteAddress, remotePort } = resolveUserRemoteAddress(req);
 
     const context = getCurrentContextResolver();
@@ -57,11 +59,12 @@ const addContext = async function middlewareWithContext(
 
       const tokenObject = {
         _id: (req as any).sessionID,
+        userId: user._id,
         /* eslint-disable-next-line */
         tokenExpires: new Date((req as any).session?.cookie._expires),
       };
 
-      await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, { userId: user._id, ...tokenObject });
+      await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, tokenObject);
 
       /* eslint-disable-next-line */
       (user as any)._inLoginMethodResponse = true;
@@ -93,6 +96,8 @@ const addContext = async function middlewareWithContext(
       return true;
     };
 
+    const [, accessToken] = req.headers.authorization?.split(' ') || [];
+
     (req as any).unchainedContext = await context({
       setHeader,
       getHeader,
@@ -100,7 +105,7 @@ const addContext = async function middlewareWithContext(
       remotePort,
       login,
       logout,
-      user: (req as any).user,
+      accessToken,
       userId: (req as any).user?._id,
     });
     next();
@@ -114,10 +119,28 @@ export const connect = (
   {
     graphqlHandler,
     db,
-    unchainedAPI,
   }: { graphqlHandler: YogaServerInstance<any, any>; db: mongodb.Db; unchainedAPI: UnchainedCore },
 ) => {
-  const passport = setupPassport(unchainedAPI);
+  const passport = new Passport();
+
+  passport.serializeUser(function serialize(user, done) {
+    done(null, user._id);
+  });
+  passport.deserializeUser(function deserialize(_id, done) {
+    done(null, { _id });
+  });
+
+  const name = UNCHAINED_COOKIE_NAME;
+  const domain = UNCHAINED_COOKIE_DOMAIN;
+  const path = UNCHAINED_COOKIE_PATH;
+  const secure = UNCHAINED_COOKIE_INSECURE ? false : true;
+  const sameSite = ({
+    none: 'none',
+    lax: 'lax',
+    strict: 'strict',
+    '1': true,
+    '0': false,
+  }[UNCHAINED_COOKIE_SAMESITE?.trim()?.toLowerCase()] || false) as boolean | 'none' | 'lax' | 'strict';
 
   expressApp.use(
     session({
@@ -127,21 +150,20 @@ export const connect = (
         dbName: db.databaseName,
         collectionName: 'sessions',
       }),
-      name: UNCHAINED_COOKIE_NAME,
+      name,
       saveUninitialized: false,
       resave: false,
       cookie: {
-        domain: UNCHAINED_COOKIE_DOMAIN,
-        path: UNCHAINED_COOKIE_PATH,
-        sameSite: 'none',
-        secure: true,
+        domain,
+        path,
+        sameSite,
+        secure,
         httpOnly: true,
         maxAge: 1000 * 60 * 60 * 24 * 7,
       },
     }),
     passport.initialize(),
     passport.session(),
-    passport.authenticate('access-token', { session: false }),
     addContext,
   );
   expressApp.use(GRAPHQL_API_PATH, graphqlHandler.handle);

package/src/fastify/bulkImportHandler.ts

@@ -0,0 +1,62 @@
+import { createLogger } from '@unchainedshop/logger';
+import { checkAction } from '../acl.js';
+import { actions } from '../roles/index.js';
+import { Context } from '../context.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:bulk-import');
+
+const errorHandler = (res) => (e) => {
+  logger.error(e.message);
+  res.status(503);
+  return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+};
+
+const bulkImportHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & { unchainedContext: Context },
+  res,
+) => {
+  try {
+    const context = req.unchainedContext;
+    const query = req.query as any;
+
+    await checkAction(context, (actions as any).bulkImport);
+
+    const input: any = {
+      createShouldUpsertIfIDExists: !!query?.createShouldUpsertIfIDExists,
+      updateShouldUpsertIfIDNotExists: !!query?.updateShouldUpsertIfIDNotExists,
+      skipCacheInvalidation: !!query?.skipCacheInvalidation,
+      remoteAddress: context.remoteAddress,
+    };
+
+    const date = new Date().toISOString();
+
+    const file = await context.services.files.uploadFileFromStream({
+      directoryName: 'bulk-import-streams',
+      rawFile: Promise.resolve({ filename: `${date}.json`, createReadStream: () => req }),
+      meta: {},
+    });
+
+    input.payloadId = file._id;
+    input.payloadSize = file.size;
+
+    const purgedInput = Object.fromEntries(Object.entries(input).filter(([, value]) => Boolean(value)));
+
+    const work = await context.modules.worker.addWork({
+      type: 'BULK_IMPORT',
+      input: purgedInput,
+      retries: 0,
+      priority: 10,
+    });
+
+    const body = JSON.stringify(work);
+    res.status(200);
+    res.header('Content-Length', Buffer.byteLength(body));
+    res.header('Content-Type', 'application/json');
+    return res.send(body);
+  } catch (e) {
+    errorHandler(res)(e);
+  }
+};
+
+export default bulkImportHandler;

package/src/fastify/ercMetadataHandler.ts

@@ -0,0 +1,50 @@
+import { createLogger } from '@unchainedshop/logger';
+import { Context } from '../context.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:erc-metadata');
+
+const errorHandler = (res) => (e) => {
+  logger.error(e.message);
+  res.status(503);
+  return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+};
+
+const notFoundHandler = (res) => {
+  logger.error('Method not supported, return 404');
+  res.status(404);
+  return res.send();
+};
+
+const ercMetadataHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & { unchainedContext: Context },
+  res,
+) => {
+  try {
+    const { services, localeContext } = req.unchainedContext;
+    const url = new URL(req.url, process.env.ROOT_URL);
+
+    if (!url.pathname.toLowerCase().endsWith('.json')) throw new Error('Invalid ERC Metadata URI');
+
+    const { productId, localeOrTokenFilename, tokenFileName } = req.params as any;
+    const locale = tokenFileName ? new Intl.Locale(localeOrTokenFilename) : localeContext;
+
+    const ercMetadata = await services.warehousing.ercMetadata({
+      productId,
+      locale,
+      chainTokenId: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
+    });
+
+    if (!ercMetadata) return notFoundHandler(res);
+
+    const body = JSON.stringify(ercMetadata);
+    res.status(200);
+    res.header('Content-Length', Buffer.byteLength(body));
+    res.header('Content-Type', 'application/json');
+    return res.send(body);
+  } catch (e) {
+    return errorHandler(res)(e);
+  }
+};
+
+export default ercMetadataHandler;

package/src/fastify/index.ts

@@ -1,6 +1,6 @@
 import { getCurrentContextResolver } from '../context.js';
-// import createBulkImportMiddleware from './createBulkImportMiddleware.js';
-// import createERCMetadataMiddleware from './createERCMetadataMiddleware.js';
+import bulkImportHandler from './bulkImportHandler.js';
+import ercMetadataHandler from './ercMetadataHandler.js';
 import MongoStore from 'connect-mongo';
 import { YogaServerInstance } from 'graphql-yoga';
 import { mongodb } from '@unchainedshop/mongodb';
@@ -11,6 +11,7 @@ import { User } from '@unchainedshop/core-users';
 import { IncomingMessage } from 'http';
 import fastifySession from '@fastify/session';
 import fastifyCookie from '@fastify/cookie';
+import { FastifyInstance } from 'fastify';
 
 const resolveUserRemoteAddress = (req: IncomingMessage) => {
   const remoteAddress =
@@ -25,10 +26,13 @@ const resolveUserRemoteAddress = (req: IncomingMessage) => {
 
 const {
   GRAPHQL_API_PATH = '/graphql',
+  BULK_IMPORT_API_PATH = '/bulk-import',
+  ERC_METADATA_API_PATH = '/erc-metadata/:productId/:localeOrTokenFilename/:tokenFileName?',
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
-  NODE_ENV,
+  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 
 const middlewareHook = async function middlewareHook(req: any, reply: any) {
@@ -40,13 +44,13 @@ const middlewareHook = async function middlewareHook(req: any, reply: any) {
 
   async function login(user: User) {
     req.session.user = user;
-    req.session.userId = user._id;
     const tokenObject = {
       _id: req.session.sessionId,
+      userId: user._id,
       /* eslint-disable-next-line */
       tokenExpires: new Date((req as any).session?.cookie._expires),
     };
-    await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, { userId: user._id, ...tokenObject });
+    await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, tokenObject);
     /* eslint-disable-next-line */
     (user as any)._inLoginMethodResponse = true;
     return { user, ...tokenObject };
@@ -54,17 +58,18 @@ const middlewareHook = async function middlewareHook(req: any, reply: any) {
 
   async function logout() {
     /* eslint-disable-line */
-    if (!req.session?.userId) return false;
+    if (!req.session?.user?._id) return false;
     const tokenObject = {
       _id: (req as any).session.sessionId,
-      userId: req.session?.userId,
+      userId: req.session?.user?._id,
     };
     req.session.user = null;
-    req.session.userId = null;
     await emit(API_EVENTS.API_LOGOUT, tokenObject);
     return true;
   }
 
+  const [, accessToken] = req.headers.authorization?.split(' ') || [];
+
   (req as any).unchainedContext = await context({
     setHeader,
     getHeader,
@@ -72,32 +77,45 @@ const middlewareHook = async function middlewareHook(req: any, reply: any) {
     remotePort,
     login,
     logout,
-    user: req.session.user,
-    userId: req.session.userId,
+    accessToken,
+    userId: req.session.user?._id,
   });
 };
 
 export const connect = (
-  fastify: any,
+  fastify: FastifyInstance,
   {
     graphqlHandler,
     db,
   }: { graphqlHandler: YogaServerInstance<any, any>; db: mongodb.Db; unchainedAPI: UnchainedCore },
 ) => {
+  const cookieName = UNCHAINED_COOKIE_NAME;
+  const domain = UNCHAINED_COOKIE_DOMAIN;
+  const path = UNCHAINED_COOKIE_PATH;
+  const secure = UNCHAINED_COOKIE_INSECURE ? false : true;
+  const sameSite = ({
+    none: 'none',
+    lax: 'lax',
+    strict: 'strict',
+    '1': true,
+    '0': false,
+  }[UNCHAINED_COOKIE_SAMESITE?.trim()?.toLowerCase()] || false) as boolean | 'none' | 'lax' | 'strict';
+
   fastify.register(fastifyCookie);
   fastify.register(fastifySession, {
     secret: process.env.UNCHAINED_TOKEN_SECRET,
-    cookieName: UNCHAINED_COOKIE_NAME,
+    cookieName,
     store: MongoStore.create({
       client: (db as any).client,
       dbName: db.databaseName,
       collectionName: 'sessions',
     }),
     cookie: {
-      domain: UNCHAINED_COOKIE_DOMAIN,
-      httpOnly: Boolean(NODE_ENV === 'production'),
-      path: UNCHAINED_COOKIE_PATH,
-      secure: NODE_ENV === 'production',
+      domain,
+      httpOnly: true,
+      path,
+      secure,
+      sameSite,
       maxAge: 1000 * 60 * 60 * 24 * 7,
     },
   });
@@ -123,6 +141,15 @@ export const connect = (
     },
   });
 
-  //   expressApp.use(ERC_METADATA_API_PATH, createERCMetadataMiddleware);
-  //   expressApp.use(BULK_IMPORT_API_PATH, createBulkImportMiddleware);
+  fastify.route({
+    url: ERC_METADATA_API_PATH,
+    method: ['GET'],
+    handler: ercMetadataHandler,
+  });
+
+  fastify.route({
+    url: BULK_IMPORT_API_PATH,
+    method: ['POST'],
+    handler: bulkImportHandler,
+  });
 };