@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc10

package/src/api-index.ts

@@ -3,14 +3,15 @@ import {
   createContextResolver,
   setCurrentContextResolver,
   getCurrentContextResolver,
+  AdminUiConfig,
 } from './context.js';
 import { UnchainedCore } from '@unchainedshop/core';
-import { AdminUiConfig } from './types.js';
 
 export * from './context.js';
-export * from './types.js';
+export * from './locale-context.js';
+export * from './loaders/index.js';
+export * from './errors.js';
 export * as acl from './acl.js';
-export * as errors from './errors.js';
 export * as roles from './roles/index.js';
 export { createContextResolver, getCurrentContextResolver, setCurrentContextResolver };
 

package/src/context.ts

@@ -1,10 +1,41 @@
-import fs from 'fs';
-import path from 'path';
 import { UnchainedCore } from '@unchainedshop/core';
-import instantiateLoaders from './loaders/index.js';
-import { getLocaleContext } from './locale-context.js';
+import instantiateLoaders, { UnchainedLoaders } from './loaders/index.js';
+import { getLocaleContext, UnchainedLocaleContext } from './locale-context.js';
 import { UnchainedServerOptions } from './api-index.js';
-import { Context, UnchainedHTTPServerContext } from './types.js';
+import { User } from '@unchainedshop/core-users';
+
+export interface UnchainedUserContext {
+  login: (user: User) => Promise<{ _id: string; tokenExpires: Date }>;
+  logout: () => Promise<boolean>;
+  userId?: string;
+  user?: User;
+  remoteAddress?: string;
+  remotePort?: string;
+  userAgent?: string;
+}
+
+export interface CustomAdminUiProperties {
+  entityName: string;
+  inlineFragment: string;
+}
+
+export interface AdminUiConfig {
+  customProperties?: CustomAdminUiProperties[];
+}
+
+export type UnchainedHTTPServerContext = {
+  setHeader: (key: string, value: string) => void;
+  getHeader: (key: string) => string;
+};
+
+export type Context = UnchainedCore & {
+  version?: string;
+  roles?: any;
+  adminUiConfig?: AdminUiConfig;
+} & UnchainedUserContext &
+  UnchainedLocaleContext &
+  UnchainedLoaders &
+  UnchainedHTTPServerContext;
 
 let context;
 
@@ -18,42 +49,40 @@ export type UnchainedContextResolver = (
   params: UnchainedHTTPServerContext & {
     remoteAddress?: string;
     remotePort?: number;
-    user?: any;
     userId?: string;
     login: (user: any) => Promise<{ _id: string; user: any; tokenExpires: Date }>;
+    accessToken?: string;
     logout: () => Promise<boolean>;
   },
 ) => Promise<Context>;
 
-export const loadJSON = (filename) => {
-  try {
-    const base = typeof __filename !== 'undefined' && __filename;
-    if (!base)
-      return {
-        version: process.env.npm_package_version,
-      };
-    const absolutePath = path.resolve(path.dirname(base), filename);
-    const data = JSON.parse(fs.readFileSync(absolutePath, 'utf-8'));
-    return data;
-  } catch {
-    return null;
-  }
-};
-
-const packageJson = loadJSON('../package.json');
-
-const { UNCHAINED_API_VERSION = packageJson?.version || '2.x' } = process.env;
+const { default: packageJson } = await import(`${import.meta.dirname}/../package.json`, {
+  with: { type: 'json' },
+});
+const { UNCHAINED_API_VERSION = packageJson?.version || '3.x' } = process.env;
 
 export const createContextResolver =
   (
     unchainedAPI: UnchainedCore,
     unchainedConfig: Pick<UnchainedServerOptions, 'roles' | 'adminUiConfig'>,
   ): UnchainedContextResolver =>
-  async ({ getHeader, setHeader, remoteAddress, remotePort, user, userId, login, logout }) => {
+  async ({ getHeader, setHeader, remoteAddress, remotePort, userId, accessToken, login, logout }) => {
     const abstractHttpServerContext = { remoteAddress, remotePort, getHeader, setHeader };
     const loaders = await instantiateLoaders(unchainedAPI);
     const localeContext = await getLocaleContext(abstractHttpServerContext, unchainedAPI);
-    const userContext = { user, userId, login, logout };
+    const userContext: UnchainedUserContext = { login, logout };
+
+    if (accessToken) {
+      const accessTokenUser = await unchainedAPI.modules.users.findUserByToken(accessToken);
+      if (accessTokenUser) {
+        userContext.user = accessTokenUser;
+        userContext.userId = accessTokenUser._id;
+      }
+    }
+    if (userId && !userContext.userId) {
+      userContext.user = await unchainedAPI.modules.users.findUserById(userId);
+      userContext.userId = userId;
+    }
 
     return {
       ...unchainedAPI,

package/src/errors.ts

@@ -79,6 +79,8 @@ export const UserWebAuthnCredentialsNotFoundError = createError(
   'User WebAuth Credentials not found',
 );
 
+export const WebAuthnDisabledError = createError('WebAuthnDisabledError', 'WebAuthn disabled');
+
 export const UserWeb3AddressNotFoundError = createError(
   'UserWeb3AddressNotFoundError',
   'Web3 Account not found for User',
@@ -101,10 +103,22 @@ export const OrderNumberAlreadyExistsError = createError(
   'OrderNumberAlreadyExistsError',
   'This orderNumber has already been used by another order',
 );
+
 export const OrderDiscountNotFoundError = createError(
   'OrderDiscountNotFoundError',
   'Order discount not found',
 );
+
+export const OrderDiscountCodeNotValidError = createError(
+  'OrderDiscountCodeNotValidError',
+  'Order discount code not valid',
+);
+
+export const OrderDiscountCodeAlreadyPresentError = createError(
+  'OrderDiscountCodeAlreadyPresentError',
+  'Order discount code already present',
+);
+
 export const OrderDeliveryNotFoundError = createError(
   'OrderDeliveryNotFoundError',
   'Order delivery not found',

package/src/express/createBulkImportMiddleware.ts

@@ -1,8 +1,7 @@
 import { createLogger } from '@unchainedshop/logger';
 import { checkAction } from '../acl.js';
 import { actions } from '../roles/index.js';
-import { IncomingMessage } from 'http';
-import { Context } from '../types.js';
+import { Context } from '../context.js';
 
 const logger = createLogger('unchained:bulk-import');
 
@@ -19,7 +18,7 @@ const methodWrongHandler = (res) => () => {
 };
 
 export default async function bulkImportMiddleware(
-  req: IncomingMessage & { query?: any; unchainedContext: Context },
+  req: Request & { query?: any; unchainedContext: Context },
   res,
 ) {
   try {
@@ -41,14 +40,11 @@ export default async function bulkImportMiddleware(
 
     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: {},
-      },
-      context,
-    );
+    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;

package/src/express/createERCMetadataMiddleware.ts

@@ -1,8 +1,7 @@
-import { IncomingMessage } from 'http';
-import path from 'path';
+import path from 'node: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,19 +1,18 @@
-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';
 import { API_EVENTS } from '../events.js';
 import { User } from '@unchainedshop/core-users';
-import { IncomingMessage } from 'http';
 
-const resolveUserRemoteAddress = (req: IncomingMessage) => {
+const resolveUserRemoteAddress = (req: e.Request) => {
   const remoteAddress =
     (req.headers['x-real-ip'] as string) ||
     (req.headers['x-forwarded-for'] as string) ||
@@ -31,6 +30,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 +41,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 +58,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 +95,8 @@ const addContext = async function middlewareWithContext(
       return true;
     };
 
+    const [, accessToken] = req.headers.authorization?.split(' ') || [];
+
     (req as any).unchainedContext = await context({
       setHeader,
       getHeader,
@@ -100,7 +104,7 @@ const addContext = async function middlewareWithContext(
       remotePort,
       login,
       logout,
-      user: (req as any).user,
+      accessToken,
       userId: (req as any).user?._id,
     });
     next();
@@ -114,10 +118,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 +149,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';
@@ -8,11 +8,11 @@ import { UnchainedCore } from '@unchainedshop/core';
 import { emit } from '@unchainedshop/events';
 import { API_EVENTS } from '../events.js';
 import { User } from '@unchainedshop/core-users';
-import { IncomingMessage } from 'http';
 import fastifySession from '@fastify/session';
 import fastifyCookie from '@fastify/cookie';
+import { FastifyInstance, FastifyRequest } from 'fastify';
 
-const resolveUserRemoteAddress = (req: IncomingMessage) => {
+const resolveUserRemoteAddress = (req: FastifyRequest) => {
   const remoteAddress =
     (req.headers['x-real-ip'] as string) ||
     (req.headers['x-forwarded-for'] as string) ||
@@ -25,10 +25,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 +43,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 +57,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 +76,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 +140,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,
+  });
 };