@unchainedshop/api 1.1.3

package/package.js

@@ -0,0 +1,33 @@
+Package.describe({
+  name: 'unchained:api',
+  version: '1.1.3',
+  summary: 'Unchained Engine: GraphQL API',
+  git: 'https://github.com/unchainedshop/unchained',
+  documentation: 'README.md',
+});
+
+Npm.depends({
+  accounting: '0.4.1',
+  'lru-cache': '7.7.0',
+  'abort-controller': '3.0.0',
+  dataloader: '2.0.0',
+  locale: '0.1.0',
+  '@unchainedshop/logger': '1.1.3',
+  '@unchainedshop/utils': '1.1.3',
+  // '@unchainedshop/roles': '1.1.3', // PEER
+  // '@unchainedshop/events': '1.1.4', // PEER
+  // '@unchainedshop/core': '1.1.3', // PEER
+  // 'graphql-scalars': '1.9.0', // needs to be peer dep!
+  // graphql peer dep
+  // apollo-server-express peer dep
+});
+
+Package.onUse((api) => {
+  api.versionsFrom('2.7.3');
+
+  api.use('ecmascript');
+  api.use('webapp');
+  api.use('typescript');
+
+  api.mainModule('src/api-index.ts', 'server');
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@unchainedshop/api",
+  "version": "1.1.3",
+  "main": "lib/api-index.js",
+  "types": "lib/api-index.d.ts",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf lib",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "watch": "tsc --watch",
+    "link:core": "npm link @unchainedshop/types",
+    "test": "cross-env METEOR_PACKAGE_DIRS=../ TEST_WATCH=1 meteor test-packages ./ --driver-package meteortesting:mocha --port 4200"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unchainedshop/unchained.git"
+  },
+  "keywords": [
+    "unchained",
+    "ecommerce",
+    "api"
+  ],
+  "author": "Joël Meiller",
+  "license": "EUPL-1.2",
+  "bugs": {
+    "url": "https://github.com/unchainedshop/unchained/issues"
+  },
+  "homepage": "https://github.com/unchainedshop/unchained#readme",
+  "peerDependencies": {
+    "@unchainedshop/roles": "1.1.x",
+    "@unchainedshop/events": "1.1.x",
+    "@unchainedshop/core": "1.1.x",
+    "apollo-server-express": "2.x",
+    "graphql-scalars": "^1.x",
+    "graphql": "^15.x"
+  },
+  "dependencies": {
+    "@unchainedshop/logger": "1.1.3",
+    "@unchainedshop/utils": "^1.1.4",
+    "accounting": "0.4.1",
+    "dataloader": "^2.1.0",
+    "locale": "0.1.0",
+    "lodash.isnumber": "3.0.3",
+    "lru-cache": "^7.10.2"
+  },
+  "devDependencies": {
+    "@types/graphql-upload": "^8.0.11",
+    "@types/locale": "^0.1.1",
+    "@unchainedshop/events": "1.1.x",
+    "@unchainedshop/roles": "1.1.x",
+    "@unchainedshop/types": "1.1.x",
+    "@unchainedshop/core": "1.1.x",
+    "apollo-server-express": "^2.25.4",
+    "chai": "^4.3.6",
+    "cross-env": "^7.0.3",
+    "graphql": "^15.8.0",
+    "graphql-scalars": "^1.17.0",
+    "typescript": "^4.7.4"
+  }
+}

package/src/acl.ts

@@ -0,0 +1,97 @@
+import { CheckPermissionArgs } from '@unchainedshop/types/roles';
+import { Roles } from '@unchainedshop/roles';
+import { NoPermissionError, PermissionSystemError } from './errors';
+
+const defaultOptions = {
+  showKey: true,
+  mapArgs: (...args) => args,
+};
+
+const emptyObject = {};
+const emptyArray: CheckPermissionArgs = [];
+
+const ensureActionExists = (action, userOptions) => {
+  if (!action) {
+    throw new PermissionSystemError({ userOptions });
+  }
+};
+
+const ensureIsFunction = (fn, action, options, key) => {
+  if (typeof fn !== 'function') {
+    throw new PermissionSystemError({
+      action,
+      key: options.showKey ? key : '',
+    });
+  }
+};
+
+const checkAction = async (context, action, args = emptyArray, options: any = emptyObject) => {
+  const { key } = options || emptyObject;
+
+  const hasPermission = await Roles.userHasPermission(context, action, args);
+  if (hasPermission) return;
+
+  const keyText = key && key !== '' ? ` in "${key}"` : '';
+
+  throw new NoPermissionError({
+    userId: context.userId,
+    action,
+    key,
+    message: `The user "${
+      context.userId || ''
+    }" has no permission to perform the action "${action}"${keyText}`,
+  });
+};
+
+const wrapFunction = (fn, name, action, userOptions) => {
+  const key = name || fn.name;
+  const options = { ...defaultOptions, ...userOptions };
+  ensureIsFunction(fn, action, options, key);
+  return async (root, params, context, ...other) => {
+    const args = options.mapArgs(root, params, ...other);
+    await checkAction(context, action, args, {
+      key: options.showKey ? key : '',
+    });
+    return fn(root, params, context, ...other);
+  };
+};
+
+const checkResolver = (action, userOptions) => {
+  ensureActionExists(action, userOptions);
+  return (fn, name) => wrapFunction(fn, name, action, userOptions);
+};
+
+const checkTypeResolver = (action, key) =>
+  async function _checkTypeResolver(obj, params, context) {
+    await checkAction(context, action, [obj, params]);
+    if (typeof obj[key] === 'function') {
+      return obj[key](params, context);
+    }
+    return obj[key];
+  };
+
+const resolverDecorator = function resolverDecorator(action, userOptions) {
+  ensureActionExists(action, userOptions);
+  return function decorator(target, key, descriptor) {
+    const fn = descriptor.value || target[key];
+    return {
+      configurable: true,
+      get() {
+        const value = wrapFunction(fn, key, action, userOptions);
+        Object.defineProperty(this, key, {
+          value,
+          configurable: true,
+          writable: true,
+        });
+        return value;
+      },
+    };
+  };
+};
+
+export default resolverDecorator;
+
+// @resolverDecorator(action)
+// resolverToBeChecked: () => ...
+
+export { resolverDecorator, checkResolver, checkTypeResolver, checkAction };

package/src/api-index.ts

@@ -0,0 +1,36 @@
+import { UnchainedServerOptions } from '@unchainedshop/types/api';
+import createBulkImportServer from './createBulkImportServer';
+import createGraphQLServer from './createGraphQLServer';
+import { createContextResolver, getCurrentContextResolver, setCurrentContextResolver } from './context';
+
+export * from './context';
+export * as acl from './acl';
+export * as errors from './errors';
+export { hashPassword } from './hashPassword';
+export * as roles from './roles';
+
+export { createContextResolver, getCurrentContextResolver, setCurrentContextResolver };
+
+const UNCHAINED_API_VERSION = '1.1.3'; // eslint-disable-line
+
+export const startAPIServer = (options: UnchainedServerOptions) => {
+  const { unchainedAPI, roles, context: customContext, ...apolloServerOptions } = options || {};
+
+  const contextResolver = createContextResolver(unchainedAPI, roles, UNCHAINED_API_VERSION);
+
+  setCurrentContextResolver(
+    customContext
+      ? ({ req, res }) => {
+          return customContext({ req, res }, contextResolver);
+        }
+      : contextResolver,
+  );
+
+  const apolloGraphQLServer = createGraphQLServer(apolloServerOptions);
+  const bulkImportServer = createBulkImportServer();
+
+  return {
+    apolloGraphQLServer,
+    bulkImportServer,
+  };
+};

package/src/context.ts

@@ -0,0 +1,44 @@
+import { UnchainedAPI, UnchainedContextResolver } from '@unchainedshop/types/api';
+import { WebApp } from 'meteor/webapp';
+import { IncomingMessage } from 'http';
+import instantiateLoaders from './loaders';
+import { getLocaleContext } from './locale-context';
+import { getUserContext } from './user-context';
+
+let context;
+
+export const getCurrentContextResolver = (): UnchainedContextResolver => context;
+
+export const setCurrentContextResolver = (newContext: UnchainedContextResolver) => {
+  context = newContext;
+};
+
+export const createContextResolver =
+  (unchainedAPI: UnchainedAPI, roles: any, version: string): UnchainedContextResolver =>
+  async ({ req, res, ...apolloContext }) => {
+    const loaders = await instantiateLoaders(req, unchainedAPI);
+    const userContext = await getUserContext(req, unchainedAPI);
+    const localeContext = await getLocaleContext(req, unchainedAPI);
+
+    return {
+      req,
+      res,
+      ...apolloContext,
+      ...unchainedAPI,
+      ...userContext,
+      ...localeContext,
+      loaders,
+      roles,
+      version,
+    };
+  };
+
+export const useMiddlewareWithCurrentContext = (path, middleware) => {
+  WebApp.connectHandlers.use(
+    path,
+    async (req: IncomingMessage & { unchainedContext?: UnchainedAPI }, res, ...rest) => {
+      req.unchainedContext = await context({ req, res });
+      return middleware(req, res, ...rest);
+    },
+  );
+};

package/src/createBulkImportServer.ts

@@ -0,0 +1,95 @@
+import { createLogger } from '@unchainedshop/logger';
+import { Context } from '@unchainedshop/types/api';
+import fs from 'fs';
+
+import { checkAction } from './acl';
+import { actions } from './roles';
+
+import { useMiddlewareWithCurrentContext } from './context';
+
+const logger = createLogger('unchained:api');
+
+const { BULK_IMPORT_API_PATH = '/bulk-import' } = process.env;
+
+const errorHandler = (res) => (e) => {
+  logger.error(e.message);
+  res.writeHead(503);
+  res.end(JSON.stringify(e));
+};
+
+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;
+};
+
+const bulkImportMiddleware = async (req, res) => {
+  try {
+    if (req.method !== 'POST') {
+      methodWrongHandler(res)();
+      return;
+    }
+
+    const resolvedContext = req.unchainedContext as Context;
+    await checkAction(resolvedContext, (actions as any).bulkImport);
+
+    const input: any = {
+      createShouldUpsertIfIDExists: !!req.query?.createShouldUpsertIfIDExists,
+      skipCacheInvalidation: !!req.query?.skipCacheInvalidation,
+      fsPayloadCacheDirectory: req.query?.fsPayloadCacheDirectory,
+      remoteAddress: resolvedContext.remoteAddress,
+    };
+
+    const stream = input.fsPayloadCacheDirectory
+      ? createWriteStreamToFilesystem(input.fsPayloadCacheDirectory)
+      : createWriteStreamToMongoDB(resolvedContext.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 resolvedContext.modules.worker.addWork(
+            {
+              type: 'BULK_IMPORT',
+              input: Object.fromEntries(Object.entries(input).filter(([, value]) => Boolean(value))),
+              retries: 0,
+              priority: 10,
+            },
+            resolvedContext.userId,
+          );
+          res.writeHead(200);
+          res.end(JSON.stringify(work));
+        } catch (e) {
+          errorHandler(res)(e);
+        }
+      });
+  } catch (e) {
+    errorHandler(res)(e);
+  }
+};
+
+export default () => {
+  useMiddlewareWithCurrentContext(BULK_IMPORT_API_PATH, bulkImportMiddleware);
+};

package/src/createGraphQLServer.ts

@@ -0,0 +1,109 @@
+import { ApolloServer, ApolloError } from 'apollo-server-express';
+import { processRequest } from 'graphql-upload';
+import { WebApp } from 'meteor/webapp';
+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 {
+      message,
+      extensions: {
+        exception: { stacktrace, ...parameters },
+        ...extensions
+      },
+      ...rest
+    } = error;
+    log(`${message} ${extensions && extensions.code}`, {
+      level: LogLevel.Error,
+      ...extensions,
+      ...rest,
+    });
+    console.error(stacktrace, parameters); // eslint-disable-line
+  } catch (e) {} // eslint-disable-line
+};
+
+export default (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 {
+        message,
+        path,
+        extensions: { exception, code, ...extensions }, // eslint-disable-line
+      } = error;
+      const apolloError = new ApolloError(message, code as string, {
+        code,
+        ...extensions,
+      });
+      apolloError.path = path;
+      return apolloError;
+    },
+    engine: APOLLO_ENGINE_KEY
+      ? {
+          apiKey: APOLLO_ENGINE_KEY,
+          privateVariables: ['email', 'plainPassword', 'oldPlainPassword', 'newPlainPassword'],
+          ...engine,
+        }
+      : undefined,
+    ...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;
+
+  const middleware = server.getMiddleware({
+    path: '/graphql',
+    cors: !originFn
+      ? undefined
+      : {
+          origin: originFn,
+          credentials: true,
+        },
+    bodyParserConfig: {
+      limit: '5mb',
+    },
+  });
+
+  WebApp.connectHandlers.use(handleUploads({ maxFileSize: 10000000, maxFiles: 10 }));
+  WebApp.connectHandlers.use(middleware);
+  return server;
+};

package/src/errors.ts

@@ -0,0 +1,174 @@
+import { ApolloError } from 'apollo-server-express';
+
+export const createError = (code: string, message: string): any =>
+  class extends ApolloError {
+    constructor({ message: explicitMessage, ...data }) {
+      super(explicitMessage || message, code, data);
+    }
+  };
+
+export const PermissionSystemError = createError('PermissionSystemError', 'Permission System Error');
+export const NoPermissionError = createError('NoPermissionError', 'Not authorized');
+export const ProductNotFoundError = createError('ProductNotFoundError', 'Product not found');
+
+export const ProductVariationNotFoundError = createError(
+  'ProductVariationNotFoundError',
+  'Product variation not found',
+);
+
+export const ProductMediaNotFoundError = createError(
+  'ProductMediaNotFoundError',
+  'Product media not found',
+);
+
+export const ProductReviewNotFoundError = createError(
+  'ProductReviewNotFoundError',
+  'ProductReview not found',
+);
+export const ProductWrongStatusError = createError(
+  'ProductWrongStatusError',
+  'The current status of the product does not allow this operation',
+);
+
+export const ProductWrongTypeError = createError(
+  'ProductWrongTypeError',
+  'The current type of the product does not allow this operation',
+);
+
+export const AssortmentNotFoundError = createError('AssortmentNotFoundError', 'Assortment not found');
+
+export const AssortmentFilterNotFoundError = createError(
+  'AssortmentFilterNotFoundError',
+  'Assortment filter not found',
+);
+
+export const AssortmentLinkNotFoundError = createError(
+  'AssortmentLinkNotFoundError',
+  'Assortment link not found',
+);
+
+export const AssortmentProductNotFoundError = createError(
+  'AssortmentProductNotFoundError',
+  'Assortment product not found',
+);
+
+export const AssortmentMediaNotFoundError = createError(
+  'AssortmentMediaNotFoundError',
+  'Assortment media not found',
+);
+export const FilterNotFoundError = createError('FilterNotFoundError', 'Filter not found');
+
+export const CountryNotFoundError = createError('CountryNotFoundError', 'Country not found');
+export const CurrencyNotFoundError = createError('CurrencyNotFoundError', 'Currency not found');
+
+export const DeliverProviderNotFoundError = createError(
+  'DeliverProviderNotFoundError',
+  'Delivery provider not found',
+);
+
+export const LanguageNotFoundError = createError('LanguageNotFoundError', 'Language not found');
+
+export const UserNotFoundError = createError('UserNotFoundError', 'User not found');
+export const UserNoCartError = createError('UserNoCartError', 'No open cart available to checkout');
+export const OrderItemNotFoundError = createError('OrderItemNotFoundError', 'Order Item not found');
+export const OrderNotFoundError = createError('OrderNotFoundError', 'Order not found');
+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 OrderDeliveryNotFoundError = createError(
+  'OrderDeliveryNotFoundError',
+  'Order delivery not found',
+);
+export const OrderPaymentNotFoundError = createError(
+  'OrderPaymentNotFoundError',
+  'Order payment not found',
+);
+
+export const OrderPaymentTypeError = createError(
+  'OrderPaymentTypeError',
+  'The current type of the order payment does not allow this operation',
+);
+
+export const OrderQuantityTooLowError = createError(
+  'OrderQuantityTooLowError',
+  'Quantity cannot be lower than 1',
+);
+export const OrderWrongPaymentStatusError = createError(
+  'OrderWrongPaymentStatus',
+  'The current status of the payment does not allow this operation',
+);
+export const OrderWrongDeliveryStatusError = createError(
+  'OrderWrongDeliveryStatus',
+  'The current status of the delivery does not allow this operation',
+);
+
+export const OrderDeliveryTypeError = createError(
+  'OrderDeliveryTypeError',
+  'The current type of the order delivery does not allow this operation',
+);
+
+export const OrderWrongStatusError = createError(
+  'OrderWrongStatusError',
+  'The current status of the order does not allow this operation',
+);
+export const OrderCheckoutError = createError(
+  'OrderCheckoutError',
+  'A problem occured while processing the order',
+);
+export const OrderPaymentConfigurationError = createError(
+  'OrderPaymentConfigurationError',
+  'Payment configuration invalid',
+);
+export const QuotationWrongStatusError = createError(
+  'QuotationWrongStatusError',
+  'The current status of the quotation does not allow this operation',
+);
+export const QuotationNotFoundError = createError('QuotationNotFoundError', 'Quotation not found');
+export const BookmarkAlreadyExistsError = createError(
+  'BookmarkAlreadyExistsError',
+  'Bookmark already exists',
+);
+export const BookmarkNotFoundError = createError('BookmarkNotFoundError', 'Bookmark not found');
+export const QueryStringRequiredError = createError(
+  'QueryStringRequiredError',
+  'Query string is required when no assortments are in scope',
+);
+export const PaymentProviderNotFoundError = createError(
+  'PaymentProviderNotFoundError',
+  'Payment provider not found',
+);
+export const WorkNotFoundOrWrongStatus = createError(
+  'WorkNotFoundOrWrongStatus',
+  'Could not find work or no work with the correct status',
+);
+
+export const WorkNotFoundError = createError('WorkNotFoundError', 'Work not found');
+
+export const WorkTypeInvalidError = createError('WorkTypeInvalidError', 'Work type invalid');
+
+export const PaymentCredentialsNotFoundError = createError(
+  'PaymentCredentialsNotFoundError',
+  'Payment credentials not found',
+);
+export const EnrollmentWrongStatusError = createError(
+  'EnrollmentWrongStatusError',
+  'The current status of the enrollment does not allow this operation',
+);
+export const EnrollmentNotFoundError = createError('EnrollmentNotFoundError', 'Enrollment not found');
+
+export const WarehousingProviderNotFoundError = createError(
+  'WarehousingProviderNotFoundError',
+  'Warehousing provider not found',
+);
+
+export const InvalidIdError = createError('InvalidIdError', 'Invalid ID provided');
+
+export const ProviderConfigurationInvalid = createError(
+  'ProviderConfigurationInvalid',
+  'Provider Configuration invalid (check if the Adapter Key exists)',
+);

package/src/hashPassword.ts

@@ -0,0 +1,5 @@
+import crypto from 'crypto';
+
+export const hashPassword = (password) => {
+  return crypto.createHash('sha256').update(password).digest('hex');
+};