@unchainedshop/api 2.0.0-beta6 → 2.0.0-beta8

package/src/api-index.ts

@@ -1,34 +1,38 @@
 import { UnchainedServerOptions } from '@unchainedshop/types/api';
-import { ApolloServer } from 'apollo-server-express';
-import createBulkImportServer from './createBulkImportServer';
+import type { ApolloServer } from '@apollo/server';
+import fs from 'fs';
+import path from 'path';
 import createGraphQLServer from './createGraphQLServer';
-import { createContextResolver, getCurrentContextResolver, setCurrentContextResolver } from './context';
-import createERCMetadataServer from './createERCMetadataServer';
+import { createContextResolver, setCurrentContextResolver, getCurrentContextResolver } from './context';
 
 export * from './context';
 export * as acl from './acl';
 export * as errors from './errors';
+export * as express from './express';
 export { hashPassword } from './hashPassword';
 export * as roles from './roles';
-
 export { createContextResolver, getCurrentContextResolver, setCurrentContextResolver };
 
-const UNCHAINED_API_VERSION = '1.2.0'; // eslint-disable-line
+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 (e) {
+    return null;
+  }
+};
+const packageJson = loadJSON('../package.json');
+
+const UNCHAINED_API_VERSION = process.env.UNCHAINED_API_VERSION || packageJson?.version || '1.2.x';
 
-export const startAPIServer = (
-  options: UnchainedServerOptions,
-): {
-  apolloGraphQLServer: ApolloServer;
-  bulkImportServer: any;
-  ercMetadataServer: any;
-} => {
-  const {
-    unchainedAPI,
-    roles,
-    expressApp,
-    context: customContext,
-    ...apolloServerOptions
-  } = options || {};
+export const startAPIServer = async (options: UnchainedServerOptions): Promise<ApolloServer> => {
+  const { unchainedAPI, roles, context: customContext, ...apolloServerOptions } = options || {};
 
   const contextResolver = createContextResolver(unchainedAPI, roles, UNCHAINED_API_VERSION);
 
@@ -40,13 +44,5 @@ export const startAPIServer = (
       : contextResolver,
   );
 
-  const apolloGraphQLServer = createGraphQLServer(expressApp, apolloServerOptions);
-  const bulkImportServer = createBulkImportServer(expressApp);
-  const ercMetadataServer = createERCMetadataServer(expressApp);
-
-  return {
-    apolloGraphQLServer,
-    bulkImportServer,
-    ercMetadataServer,
-  };
+  return createGraphQLServer(apolloServerOptions);
 };

package/src/context.ts

@@ -1,6 +1,5 @@
 import { UnchainedContextResolver } from '@unchainedshop/types/api';
 import { UnchainedCore } from '@unchainedshop/types/core';
-import { IncomingMessage, OutgoingMessage } from 'http';
 import instantiateLoaders from './loaders';
 import { getLocaleContext } from './locale-context';
 import { getUserContext } from './user-context';
@@ -32,21 +31,3 @@ export const createContextResolver =
       version,
     };
   };
-
-export const useMiddlewareWithCurrentContext = (expressApp, path, middleware) => {
-  expressApp.use(
-    path,
-    async function middlewareWithContext(
-      req: IncomingMessage & { unchainedContext?: UnchainedCore },
-      res: OutgoingMessage,
-      next,
-    ) {
-      try {
-        req.unchainedContext = await context({ req, res });
-        await middleware(req, res, next);
-      } catch (error) {
-        next(error);
-      }
-    },
-  );
-};

package/src/createGraphQLServer.ts

@@ -1,21 +1,11 @@
-import { ApolloServer, ApolloError } from 'apollo-server-express';
-import { processRequest } from 'graphql-upload';
+import { ApolloServer } from '@apollo/server';
+import { GraphQLError } from 'graphql';
 import { log, LogLevel } from '@unchainedshop/logger';
 import typeDefs from './schema';
 import resolvers from './resolvers';
-import { getCurrentContextResolver } from './context';
 
 const { APOLLO_ENGINE_KEY } = process.env;
 
-const handleUploads = (options) => async (req, res, next) => {
-  const contentType = req.headers['content-type'];
-  const isUpload = contentType && contentType.startsWith('multipart/form-data');
-  if (isUpload) {
-    req.body = await processRequest(req, res, options);
-  }
-  next();
-};
-
 const logGraphQLServerError = (error) => {
   try {
     const {
@@ -35,21 +25,17 @@ const logGraphQLServerError = (error) => {
   } catch (e) {} // eslint-disable-line
 };
 
-export default (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],
-    context,
-    uploads: false,
     formatError: (error) => {
       logGraphQLServerError(error);
       const {
@@ -57,18 +43,20 @@ export default (expressApp, options) => {
         path,
         extensions: { exception, code, ...extensions }, // eslint-disable-line
       } = error;
-      const apolloError = new ApolloError(message, code as string, {
-        code,
-        ...extensions,
+      const apolloError = new GraphQLError(message, {
+        extensions: {
+          code,
+          ...extensions,
+        },
       });
       // eslint-disable-next-line
       // @ts-ignore
       apolloError.path = path;
       return apolloError;
     },
-    engine: APOLLO_ENGINE_KEY
+    apollo: APOLLO_ENGINE_KEY
       ? {
-          apiKey: APOLLO_ENGINE_KEY,
+          key: APOLLO_ENGINE_KEY,
           privateVariables: ['email', 'plainPassword', 'oldPlainPassword', 'newPlainPassword'],
           ...engine,
         }
@@ -76,40 +64,7 @@ export default (expressApp, options) => {
     ...apolloServerOptions,
   });
 
-  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;
-
-  // server.start().then(() => {
-  //
-  // });
-
-  const middleware = server.getMiddleware({
-    path: '/graphql',
-    cors: !originFn
-      ? undefined
-      : {
-          origin: originFn,
-          credentials: true,
-        },
-    bodyParserConfig: {
-      limit: '5mb',
-    },
-  });
-
-  expressApp.use(handleUploads({ maxFileSize: 10000000, maxFiles: 10 }));
-  expressApp.use(middleware);
+  await server.start();
 
   return server;
 };

package/src/errors.ts

@@ -1,9 +1,14 @@
-import { ApolloError } from 'apollo-server-express';
+import { GraphQLError } from 'graphql';
 
 export const createError = (code: string, message: string): any =>
-  class extends ApolloError {
+  class extends GraphQLError {
     constructor({ message: explicitMessage, ...data }) {
-      super(explicitMessage || message, code, data);
+      super(explicitMessage || message, {
+        extensions: {
+          code,
+          ...data,
+        },
+      });
     }
   };
 

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/loaders/index.ts

@@ -3,10 +3,11 @@ import DataLoader from 'dataloader';
 import { IncomingMessage, OutgoingMessage } from 'http';
 import { systemLocale } from '@unchainedshop/utils';
 import localePkg from 'locale';
-import { AssortmentText } from '@unchainedshop/types/assortments';
-import { FilterText } from '@unchainedshop/types/filters';
-import { ProductText } from '@unchainedshop/types/products';
+import { Assortment, AssortmentText } from '@unchainedshop/types/assortments';
+import { Filter, FilterText } from '@unchainedshop/types/filters';
+import { Product, ProductText } from '@unchainedshop/types/products';
 import { UnchainedCore } from '@unchainedshop/types/core';
+import { ProductStatus } from '@unchainedshop/core-products';
 
 const { Locale } = localePkg;
 
@@ -16,6 +17,28 @@ export default async (
   unchainedAPI: UnchainedCore,
 ): Promise<UnchainedLoaders['loaders']> => {
   return {
+    assortmentLoader: new DataLoader<{ assortmentId: string; includeInactive: boolean }, Assortment>(
+      async (queries) => {
+        const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+
+        const assortments = await unchainedAPI.modules.assortments.findAssortments({
+          assortmentIds,
+          includeInactive: true,
+          includeLeaves: true,
+        });
+
+        return queries.map(({ assortmentId, includeInactive }) => {
+          return assortments.find((assortment) => {
+            if (assortment._id !== assortmentId) return false;
+            if (!includeInactive) {
+              return assortment.isActive === true;
+            }
+            return true;
+          });
+        });
+      },
+    ),
+
     assortmentTextLoader: new DataLoader<{ assortmentId: string; locale: string }, AssortmentText>(
       async (queries) => {
         const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
@@ -46,6 +69,22 @@ export default async (
       },
     ),
 
+    filterLoader: new DataLoader<{ filterId: string }, Filter>(async (queries) => {
+      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+
+      const filters = await unchainedAPI.modules.filters.findFilters({
+        filterIds,
+        includeInactive: true,
+      });
+
+      return queries.map(({ filterId }) => {
+        return filters.find((product) => {
+          if (product._id !== filterId) return false;
+          return true;
+        });
+      });
+    }),
+
     filterTextLoader: new DataLoader<
       { filterId: string; filterOptionValue?: string; locale: string },
       FilterText
@@ -79,6 +118,27 @@ export default async (
       });
     }),
 
+    productLoader: new DataLoader<{ productId: string; includeDrafts: boolean }, Product>(
+      async (queries) => {
+        const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+        const products = await unchainedAPI.modules.products.findProducts({
+          productIds,
+          includeDrafts: true,
+        });
+
+        return queries.map(({ productId, includeDrafts }) => {
+          return products.find((product) => {
+            if (product._id !== productId) return false;
+            if (!includeDrafts) {
+              return product.status === ProductStatus.ACTIVE;
+            }
+            return true;
+          });
+        });
+      },
+    ),
+
     productTextLoader: new DataLoader<{ productId: string; locale: string }, ProductText>(
       async (queries) => {
         const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];

package/src/resolvers/index.ts

@@ -1,4 +1,4 @@
-import { GraphQLUpload } from 'graphql-upload';
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.mjs';
 import { JSONResolver, TimestampResolver, DateTimeResolver, DateResolver } from 'graphql-scalars';
 import Query from './queries';
 import Mutation from './mutations';