@unchainedshop/api 2.0.0-beta7 → 2.0.0-beta8

package/src/createGraphQLServer.ts

@@ -1,13 +1,8 @@
 import { ApolloServer } from '@apollo/server';
-import { expressMiddleware } from '@apollo/server/express4';
 import { GraphQLError } from 'graphql';
-import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';
 import { log, LogLevel } from '@unchainedshop/logger';
-import cors from 'cors';
-import bodyParser from 'body-parser';
 import typeDefs from './schema';
 import resolvers from './resolvers';
-import { getCurrentContextResolver } from './context';
 
 const { APOLLO_ENGINE_KEY } = process.env;
 
@@ -30,17 +25,14 @@ const logGraphQLServerError = (error) => {
   } catch (e) {} // eslint-disable-line
 };
 
-export default async (expressApp, options) => {
+export default async (options) => {
   const {
-    corsOrigins = null, // no cookie handling
     typeDefs: additionalTypeDefs = [],
     resolvers: additionalResolvers = [],
     engine = {},
     ...apolloServerOptions
   } = options || {};
 
-  const context = getCurrentContextResolver();
-
   const server = new ApolloServer({
     typeDefs: [...typeDefs, ...additionalTypeDefs],
     resolvers: [resolvers, ...additionalResolvers],
@@ -74,40 +66,5 @@ export default async (expressApp, options) => {
 
   await server.start();
 
-  const originFn =
-    corsOrigins && Array.isArray(corsOrigins)
-      ? (origin, callback) => {
-          if (corsOrigins.length === 0 || !origin) {
-            callback(null, true);
-            return;
-          }
-          if (corsOrigins.indexOf(origin) !== -1) {
-            callback(null, true);
-          } else {
-            callback(new Error('Not allowed by CORS'));
-          }
-        }
-      : corsOrigins;
-
-  expressApp.use(
-    '/graphql',
-    cors(
-      !originFn
-        ? undefined
-        : {
-            origin: originFn,
-            credentials: true,
-          },
-    ),
-    bodyParser.json(),
-    graphqlUploadExpress(),
-    expressMiddleware(server, {
-      context,
-    }),
-  );
-
-  // expressApp.use(handleUploads({ maxFileSize: 10000000, maxFiles: 10 }));
-  // expressApp.use(middleware);
-
   return server;
 };

package/src/express/createApolloMiddleware.ts

@@ -0,0 +1,40 @@
+import cors from 'cors';
+import { expressMiddleware } from '@apollo/server/express4';
+import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';
+import e from 'express';
+
+export default function createApolloMiddleware(
+  contextResolver,
+  { apolloGraphQLServer, corsOrigins = undefined },
+) {
+  const originFn =
+    corsOrigins && Array.isArray(corsOrigins)
+      ? (origin, callback) => {
+          if (corsOrigins.length === 0 || !origin) {
+            callback(null, true);
+            return;
+          }
+          if (corsOrigins.indexOf(origin) !== -1) {
+            callback(null, true);
+          } else {
+            callback(new Error('Not allowed by CORS'));
+          }
+        }
+      : corsOrigins;
+
+  return [
+    cors(
+      !originFn
+        ? undefined
+        : {
+            origin: originFn,
+            credentials: true,
+          },
+    ),
+    e.json(),
+    graphqlUploadExpress({ maxFileSize: 10000000, maxFiles: 10 }),
+    expressMiddleware(apolloGraphQLServer, {
+      context: contextResolver,
+    }),
+  ];
+}

package/src/express/createBulkImportMiddleware.ts

@@ -0,0 +1,90 @@
+import { createLogger } from '@unchainedshop/logger';
+import { UnchainedContextResolver } from '@unchainedshop/types/api';
+import fs from 'fs';
+import { checkAction } from '../acl';
+import { actions } from '../roles';
+
+const logger = createLogger('unchained:bulk-import');
+
+const { BULK_IMPORT_PAYLOAD_CACHE_DIRECTORY } = process.env;
+
+const errorHandler = (res) => (e) => {
+  logger.error(e.message);
+  res.writeHead(503);
+  res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+};
+
+const methodWrongHandler = (res) => () => {
+  logger.error('Method not supported, return 404');
+  res.writeHead(404);
+  res.end();
+};
+
+const createWriteStreamToFilesystem = (cacheDirectory) => {
+  const date = new Date().toISOString();
+  const payloadFilePath = `${cacheDirectory}/${date}.json`;
+  const stream = fs.createWriteStream(payloadFilePath, { flags: 'a' });
+  return stream;
+};
+
+const createWriteStreamToMongoDB = (BulkImportPayloads) => {
+  const date = new Date().toISOString();
+  const stream = BulkImportPayloads.openUploadStreamWithId(date, `${date}.json`, {
+    contentType: 'application/json',
+  });
+  return stream;
+};
+
+export default function bulkImportMiddleware(contextResolver: UnchainedContextResolver) {
+  return async (req, res) => {
+    try {
+      if (req.method !== 'POST') {
+        methodWrongHandler(res)();
+        return;
+      }
+
+      const context = await contextResolver({ req, res });
+      await checkAction(context, (actions as any).bulkImport);
+
+      const input: any = {
+        createShouldUpsertIfIDExists: !!req.query?.createShouldUpsertIfIDExists,
+        skipCacheInvalidation: !!req.query?.skipCacheInvalidation,
+        fsPayloadCacheDirectory: BULK_IMPORT_PAYLOAD_CACHE_DIRECTORY,
+        remoteAddress: context.remoteAddress,
+      };
+
+      const stream = input.fsPayloadCacheDirectory
+        ? createWriteStreamToFilesystem(input.fsPayloadCacheDirectory)
+        : createWriteStreamToMongoDB(context.bulkImporter.BulkImportPayloads);
+
+      req
+        .pipe(stream)
+        .on('error', errorHandler(res))
+        .on('finish', async (file) => {
+          try {
+            if (input.fsPayloadCacheDirectory) {
+              input.payloadFilePath = stream.path;
+            } else {
+              input.payloadId = file._id;
+              input.payloadSize = file.length;
+            }
+            const work = await context.modules.worker.addWork(
+              {
+                type: 'BULK_IMPORT',
+                input: Object.fromEntries(Object.entries(input).filter(([, value]) => Boolean(value))),
+                retries: 0,
+                priority: 10,
+              },
+              context.userId,
+            );
+            res.writeHead(200);
+            res.end(JSON.stringify(work));
+          } catch (e) {
+            errorHandler(res)(e);
+          }
+        });
+    } catch (e) {
+      errorHandler(res)(e);
+    }
+  };
+}

package/src/express/createERCMetadataMiddleware.ts

@@ -0,0 +1,72 @@
+import { createLogger } from '@unchainedshop/logger';
+import { UnchainedContextResolver } from '@unchainedshop/types/api';
+import { systemLocale } from '@unchainedshop/utils';
+import { IncomingMessage } from 'http';
+import localePkg from 'locale';
+import path from 'path';
+
+const { Locale } = localePkg;
+
+const logger = createLogger('unchained:erc-metadata');
+
+const errorHandler = (res) => (e) => {
+  logger.error(e.message);
+  res.writeHead(503);
+  res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+};
+
+const methodWrongHandler = (res) => () => {
+  logger.error('Method not supported, return 404');
+  res.writeHead(404);
+  res.end();
+};
+
+export default function ercMetadataMiddleware(contextResolver: UnchainedContextResolver) {
+  return async (req: IncomingMessage, res) => {
+    try {
+      if (req.method !== 'GET') {
+        methodWrongHandler(res)();
+        return;
+      }
+
+      const context = await contextResolver({ req, res });
+      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 ? localeOrTokenFilename : systemLocale.language;
+      const chainTokenId = parsedPath.name;
+
+      const product = await context.modules.products.findProduct({
+        productId,
+      });
+
+      const [token] = await context.modules.warehousing.findTokens({
+        chainTokenId,
+        contractAddress: product?.tokenization?.contractAddress,
+      });
+
+      const ercMetadata = await context.modules.warehousing.tokenMetadata(
+        chainTokenId,
+        {
+          token,
+          product,
+          referenceDate: new Date(),
+        },
+        { ...context, localeContext: new Locale(locale) },
+      );
+
+      const body = JSON.stringify(ercMetadata);
+      res.writeHead(200, {
+        'Content-Length': Buffer.byteLength(body),
+        'Content-Type': 'text/plain',
+      });
+      res.end(body);
+    } catch (e) {
+      errorHandler(res)(e);
+    }
+  };
+}

package/src/express/createSingleSignOnMiddleware.ts

@@ -0,0 +1,83 @@
+/// <reference lib="dom" />
+import { createLogger } from '@unchainedshop/logger';
+import { Context, UnchainedContextResolver } from '@unchainedshop/types/api';
+import { IncomingMessage } from 'http';
+import cookie from 'cookie';
+
+const { ROOT_URL, NODE_ENV, UNCHAINED_CLOUD_ENDPOINT } = process.env;
+
+const logger = createLogger('unchained:unchained-cloud-sso');
+
+const loginWithSingleSignOn = async (remoteToken, context: Context) => {
+  const domain = process.env.UNCHAINED_COOKIE_DOMAIN || new URL(ROOT_URL).hostname || 'localhost';
+  const result = await fetch(UNCHAINED_CLOUD_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      operationName: 'consume',
+      variables: {
+        token: remoteToken,
+      },
+      query:
+        'mutation consume($token: ID!) { controlConsumeSingleSignOnToken(token: $token) { domain } }',
+    }),
+  });
+  const json: any = await result.json();
+  if (json?.errors?.length > 0) {
+    throw new Error(json.errors[0].message);
+  }
+
+  if (domain === 'localhost' || domain === json?.data?.controlConsumeSingleSignOnToken?.domain) {
+    // create sso user if not exist and login
+    const ssoUserId =
+      (await context.modules.users.findUser({ username: 'sso' }))?._id ||
+      (await context.modules.accounts.createUser(
+        {
+          username: 'sso',
+          roles: ['admin'],
+          email: 'sso@unchained.local',
+          password: null,
+          guest: false,
+        },
+        { skipMessaging: true },
+      ));
+    const { tokenExpires, token } = await context.modules.accounts.createLoginToken(ssoUserId, context);
+    const expires = new Date(tokenExpires || new Date().getTime() + 100000);
+    const authCookie = cookie.serialize(process.env.UNCHAINED_COOKIE_NAME, token, {
+      domain,
+      httpOnly: true,
+      expires,
+      path: '/',
+      sameSite: 'strict',
+      secure: NODE_ENV === 'production',
+    });
+
+    return authCookie;
+  }
+  throw new Error('Invalid token/domain pair');
+};
+
+export default function singleSignOnMiddleware(contextResolver: UnchainedContextResolver) {
+  return async (req: IncomingMessage & { query?: any }, res, next) => {
+    try {
+      if (req.query?.token) {
+        const context = await contextResolver({ req, res });
+        const authCookie = await loginWithSingleSignOn(req.query.token, context);
+
+        if (authCookie) {
+          res.writeHead(303, {
+            'Set-Cookie': authCookie,
+            Location: '/',
+          });
+          res.end();
+          return;
+        }
+      }
+    } catch (e) {
+      logger.error(e.message);
+    }
+    next();
+  };
+}

package/src/express/index.ts

@@ -0,0 +1,48 @@
+import { UnchainedCore } from '@unchainedshop/types/core';
+import { IncomingMessage, OutgoingMessage } from 'http';
+import { ApolloServer } from '@apollo/server';
+import type e from 'express';
+import { getCurrentContextResolver } from '../context';
+import createBulkImportMiddleware from './createBulkImportMiddleware';
+import createERCMetadataMiddleware from './createERCMetadataMiddleware';
+import createApolloMiddleware from './createApolloMiddleware';
+import createSingleSignOnMiddleware from './createSingleSignOnMiddleware';
+
+const {
+  BULK_IMPORT_API_PATH = '/bulk-import',
+  ERC_METADATA_API_PATH = '/erc-metadata',
+  GRAPHQL_API_PATH = '/graphql',
+} = process.env;
+
+export const useMiddlewareWithCurrentContext = (expressApp, path, ...middleware) => {
+  const context = getCurrentContextResolver();
+  const addContext = async function middlewareWithContext(
+    req: IncomingMessage & { unchainedContext: UnchainedCore },
+    res: OutgoingMessage,
+    next,
+  ) {
+    try {
+      req.unchainedContext = await context({ req, res });
+      next();
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  expressApp.use(path, addContext, ...middleware);
+};
+
+export const connect = (
+  expressApp: e.Express,
+  { apolloGraphQLServer }: { apolloGraphQLServer: ApolloServer },
+) => {
+  const contextResolver = getCurrentContextResolver();
+
+  expressApp.use(GRAPHQL_API_PATH, createApolloMiddleware(contextResolver, { apolloGraphQLServer }));
+  expressApp.use(ERC_METADATA_API_PATH, createERCMetadataMiddleware(contextResolver));
+  expressApp.use(BULK_IMPORT_API_PATH, createBulkImportMiddleware(contextResolver));
+  expressApp.use(
+    ['/', '/.well-known/unchained/cloud-sso'],
+    createSingleSignOnMiddleware(contextResolver),
+  );
+};

package/src/resolvers/mutations/accounts/changePassword.ts

@@ -4,19 +4,17 @@ import { Context, Root } from '@unchainedshop/types/api';
 export default async function changePassword(
   root: Root,
   params: {
-    oldPassword?: string;
     oldPlainPassword?: string;
-    newPassword?: string;
     newPlainPassword?: string;
   },
   { modules, userId }: Context,
 ) {
   log('mutation changePassword', { userId });
 
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('New password is required');
   }
-  if (!params.oldPassword && !params.oldPlainPassword) {
+  if (!params.oldPlainPassword) {
     throw new Error('Old password is required');
   }
 

package/src/resolvers/mutations/accounts/createUser.ts

@@ -8,12 +8,12 @@ export default async function createUser(root: Root, params: UserData, context:
 
   log('mutation createUser', { email: params.email, username: params.username, userId });
 
-  if (!params.password && !params.plainPassword && !params.webAuthnPublicKeyCredentials) {
+  if (!params.plainPassword && !params.webAuthnPublicKeyCredentials) {
     throw new Error('Password or Public Key is required');
   }
 
   const mappedUser = { ...params };
-  if (!mappedUser.password && mappedUser.plainPassword) {
+  if (mappedUser.plainPassword) {
     mappedUser.password = hashPassword(mappedUser.plainPassword);
   }
   delete mappedUser.plainPassword;

package/src/resolvers/mutations/accounts/enrollUser.ts

@@ -10,7 +10,7 @@ export default async function enrollUser(root: Root, params: UserData, context:
 
   const mappedUserData = params;
   mappedUserData.initialPassword = true;
-  if (!mappedUserData.password && mappedUserData.plainPassword) {
+  if (mappedUserData.plainPassword) {
     mappedUserData.password = hashPassword(mappedUserData.plainPassword);
   }
   delete mappedUserData.plainPassword;

package/src/resolvers/mutations/accounts/loginWithPassword.ts

@@ -7,24 +7,23 @@ export default async function loginWithPassword(
   params: {
     username?: string;
     email?: string;
-    password?: string;
     plainPassword?: string;
     totpCode?: string;
   },
   context: Context,
 ) {
   const { modules } = context;
-  const { username, email, password: hashedPassword, plainPassword, totpCode } = params;
+  const { username, email, plainPassword, totpCode } = params;
 
   log('mutation loginWithPassword', { username, email });
 
-  if (!hashedPassword && !plainPassword) {
+  if (!plainPassword) {
     throw new Error('Password is required');
   }
 
   const mappedUserLoginParams = {
     user: email ? { email } : { username },
-    password: hashedPassword || hashPassword(plainPassword),
+    password: hashPassword(plainPassword),
     code: totpCode,
   };
 

package/src/resolvers/mutations/accounts/resetPassword.ts

@@ -3,14 +3,14 @@ import { Context, Root } from '@unchainedshop/types/api';
 
 export default async function resetPassword(
   root: Root,
-  params: { newPassword?: string; newPlainPassword?: string; token: string },
+  params: { newPlainPassword?: string; token: string },
   context: Context,
 ) {
   const { modules, userId } = context;
 
   log('mutation resetPassword', { userId });
 
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('Password is required');
   }
 

package/src/resolvers/mutations/accounts/setPassword.ts

@@ -4,7 +4,7 @@ import { UserNotFoundError, InvalidIdError } from '../../../errors';
 
 export default async function setPassword(
   root: Root,
-  params: { newPassword: string; newPlainPassword: string; userId: string },
+  params: { newPlainPassword: string; userId: string },
   { modules, userId }: Context,
 ) {
   const normalizedUserId = params.userId || userId;
@@ -12,7 +12,7 @@ export default async function setPassword(
   log(`mutation setPassword ${normalizedUserId}`, { userId });
 
   if (!normalizedUserId) throw new InvalidIdError({ userId: normalizedUserId });
-  if (!params.newPassword && !params.newPlainPassword) {
+  if (!params.newPlainPassword) {
     throw new Error('Password is required');
   }
   if (!(await modules.users.userExists({ userId: normalizedUserId })))

package/src/resolvers/mutations/assortments/removeAssortment.ts

@@ -14,7 +14,7 @@ export default async function removeAssortment(
   const assortment = await modules.assortments.findAssortment({ assortmentId });
   if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.delete(assortmentId, { skipInvalidation: false }, userId);
+  await modules.assortments.delete(assortmentId, { skipInvalidation: false });
 
   return assortment;
 }

package/src/resolvers/mutations/assortments/removeAssortmentFilter.ts

@@ -18,7 +18,7 @@ export default async function removeAssortmentFilter(
 
   if (!assortmentFilter) throw new AssortmentFilterNotFoundError({ assortmentFilterId });
 
-  await modules.assortments.filters.delete(assortmentFilterId, userId);
+  await modules.assortments.filters.delete(assortmentFilterId);
 
   return assortmentFilter;
 }

package/src/resolvers/mutations/assortments/removeAssortmentLink.ts

@@ -16,7 +16,7 @@ export default async function removeAssortmentLink(
 
   if (!assortmentLink) throw new AssortmentLinkNotFoundError({ assortmentLinkId });
 
-  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false }, userId);
+  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false });
 
   return assortmentLink;
 }

package/src/resolvers/mutations/assortments/removeAssortmentProduct.ts

@@ -18,7 +18,7 @@ export default async function removeAssortmentProduct(
   });
   if (!assortmentProduct) throw new AssortmentProductNotFoundError({ assortmentProductId });
 
-  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false }, userId);
+  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false });
 
   return assortmentProduct;
 }

package/src/resolvers/mutations/filters/removeFilter.ts

@@ -15,7 +15,7 @@ export default async function removeFilter(
   const filter = await modules.filters.findFilter({ filterId });
   if (!filter) throw new FilterNotFoundError({ filterId });
 
-  await modules.assortments.filters.deleteMany({ filterId }, userId);
+  await modules.assortments.filters.deleteMany({ filterId });
   await modules.filters.delete(filterId, userId);
 
   return filter;

package/src/resolvers/mutations/pageView.ts

@@ -1,10 +1,10 @@
 import { log } from '@unchainedshop/logger';
 import { emit } from '@unchainedshop/events';
 
-export default (root, { path, referrer }, { userId }) => {
+export default async (root, { path, referrer }, { userId }) => {
   log(`mutation pageView ${path} ${referrer}`, { userId });
 
-  emit('PAGE_VIEW', {
+  await emit('PAGE_VIEW', {
     path,
     referrer,
   });

package/src/resolvers/mutations/products/removeProduct.ts

@@ -1,23 +1,21 @@
 import { log } from '@unchainedshop/logger';
 import { Context, Root } from '@unchainedshop/types/api';
-import { ProductNotFoundError, ProductWrongStatusError, InvalidIdError } from '../../../errors';
+import { ProductNotFoundError, InvalidIdError } from '../../../errors';
 
 export default async function removeProduct(
   root: Root,
   { productId }: { productId: string },
-  { modules, userId }: Context,
+  context: Context,
 ) {
+  const { modules, services, userId } = context;
   log(`mutation removeProduct ${productId}`, { userId });
 
   if (!productId) throw new InvalidIdError({ productId });
 
-  const product = await modules.products.findProduct({ productId });
-  if (!product) throw new ProductNotFoundError({ productId });
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
 
-  if (!modules.products.isDraft(product)) throw new ProductWrongStatusError({ status: product.status });
-
-  await modules.assortments.products.delete(productId as string, {}, userId);
-  await modules.products.delete(productId, userId);
+  await services.products.removeProduct({ productId, userId: context.userId }, context);
 
   return modules.products.findProduct({ productId });
 }

package/src/resolvers/type/assortment/assortment-path-link-types.ts

@@ -9,9 +9,6 @@ type HelperType<P, T> = (assortmentPathLink: AssortmentPathLinkType, params: P,
 
 export interface AssortmentPathLinkHelperTypes {
   link: HelperType<never, Promise<AssortmentLinkType>>;
-
-  assortmentSlug: HelperType<{ forceLocale?: string }, Promise<string>>;
-
   assortmentTexts: HelperType<{ forceLocale?: string }, Promise<AssortmentText>>;
 }
 
@@ -23,14 +20,6 @@ export const AssortmentPathLink: AssortmentPathLinkHelperTypes = {
     });
   },
 
-  assortmentSlug: async ({ assortmentId }, params, { loaders, localeContext }) => {
-    const text = await loaders.assortmentTextLoader.load({
-      assortmentId,
-      locale: params.forceLocale || localeContext.normalized,
-    });
-    return text.slug;
-  },
-
   assortmentTexts: async ({ assortmentId }, params, { loaders, localeContext }) => {
     const text = await loaders.assortmentTextLoader.load({
       assortmentId,