@unchainedshop/platform 1.1.3

package/src/migrations/migrationRepository.ts

@@ -0,0 +1,18 @@
+import { Migration } from '@unchainedshop/types/api';
+import { MigrationRepository, Db } from '@unchainedshop/types/common';
+
+export const createMigrationRepository = (db: Db): MigrationRepository<Migration> => {
+  const migrations = new Map();
+  return {
+    db,
+    migrations,
+    register: (migration: Migration) => {
+      migrations.set(migration.id, migration);
+    },
+    allMigrations: () => {
+      return [...migrations.values()].sort((left, right) => {
+        return left.id - right.id;
+      });
+    },
+  };
+};

package/src/migrations/runMigrations.ts

@@ -0,0 +1,64 @@
+import { UnchainedAPI, Migration } from '@unchainedshop/types/api';
+import { MigrationRepository } from '@unchainedshop/types/common';
+import { createLogger } from '@unchainedshop/logger';
+import { generateDbFilterById } from '@unchainedshop/utils';
+import { createMigrationRunner } from './createMigrationRunner';
+
+export const runMigrations = async ({
+  migrationRepository,
+  logger = createLogger('unchained:migrations'),
+  unchainedAPI,
+}: {
+  migrationRepository: MigrationRepository<Migration>;
+  logger?: any;
+  unchainedAPI: UnchainedAPI;
+}) => {
+  const LastMigration = migrationRepository.db.collection('last-migration');
+
+  const findCurrentId = async () => {
+    const last = await LastMigration.findOne({ category: 'unchained' }, { sort: { _id: -1 } });
+    const id = last ? last._id : 0;
+    logger.verbose(`Most recent migration id: ${id}`);
+    return id;
+  };
+
+  const onMigrationComplete = async (id: string, action: string) => {
+    await LastMigration.updateOne(
+      generateDbFilterById(id, { category: 'unchained' }),
+      {
+        $set: {
+          _id: id,
+          action,
+          category: 'unchained',
+          timestamp: new Date(),
+        },
+      },
+      {
+        upsert: true,
+      },
+    );
+    logger.verbose(`Migrated '${action}' to ${id}`);
+    return id;
+  };
+
+  const currentId = await findCurrentId();
+  const runner = createMigrationRunner({
+    currentId,
+    logger,
+    migrationRepository,
+    onMigrationComplete,
+    unchainedAPI,
+  });
+
+  const [lastMigrationId, operationCount] = await runner.run();
+
+  if (operationCount !== null) {
+    if (operationCount > 0) {
+      logger.info(`All ${operationCount} migrations completed with most recent id: ${lastMigrationId}`);
+    } else {
+      logger.info(`No migrations run, already at latest id: ${currentId}`);
+    }
+  } else {
+    logger.info(`Some migrations failed, last successful id: ${lastMigrationId}`);
+  }
+};

package/src/platform-index.ts

@@ -0,0 +1,2 @@
+export * from './startPlatform';
+export * from './context';

package/src/setup/generateEventTypeDefs.js

@@ -0,0 +1,9 @@
+import { getRegisteredEvents } from '@unchainedshop/events';
+
+export const generateEventTypeDefs = () => [
+  /* GraphQL */ `
+    extend enum EventType {
+      ${getRegisteredEvents().join(',')}
+    }
+  `,
+];

package/src/setup/generateRoleActionTypeDefs.js

@@ -0,0 +1,9 @@
+import { roles } from '@unchainedshop/api';
+
+export const generateRoleActionTypeDefs = () => [
+  /* GraphQL */ `
+      extend enum RoleAction {
+        ${Object.keys(roles.actions).join(',')}
+      }
+    `,
+];

package/src/setup/generateWorkTypeDefs.js

@@ -0,0 +1,11 @@
+import { WorkerDirector } from '@unchainedshop/core-worker';
+
+export const generateWorkerTypeDefs = () => {
+  return [
+    /* GraphQL */ `
+    extend enum WorkType {
+      ${WorkerDirector.getActivePluginTypes().join(',')}
+    }
+  `,
+  ];
+};

package/src/setup/setupAccounts.ts

@@ -0,0 +1,129 @@
+import { Context } from '@unchainedshop/types/api';
+import { User } from '@unchainedshop/types/user';
+import { randomValueHex } from '@unchainedshop/utils';
+import { accountsSettings } from '@unchainedshop/core-accountsjs';
+import moniker from 'moniker';
+
+export const setupAccounts = (unchainedAPI: Context) => {
+  const accountsServer = unchainedAPI.modules.accounts.getAccountsServer();
+
+  accountsServer.users = unchainedAPI.modules.users;
+
+  accountsServer.options.prepareMail = (
+    to: string,
+    token: string,
+    user: User & { id: string },
+    pathFragment: string,
+  ) => {
+    return {
+      template: 'ACCOUNT_ACTION',
+      recipientEmail: to,
+      action: pathFragment,
+      userId: user.id || user._id,
+      token,
+      skipMessaging: !!user.guest && pathFragment === 'verify-email',
+    };
+  };
+
+  accountsServer.options.sendMail = (input: any) => {
+    if (!input) return true;
+    if (input.skipMessaging) return true;
+
+    return unchainedAPI.modules.worker.addWork(
+      {
+        type: 'MESSAGE',
+        retries: 0,
+        input,
+      },
+      unchainedAPI.userId,
+    );
+  };
+
+  accountsServer.services.guest = {
+    async authenticate(params: { email?: string | null }) {
+      const guestname = `${moniker.choose()}-${randomValueHex(5)}`;
+
+      const guestUserId = await unchainedAPI.modules.accounts.createUser(
+        {
+          email: params.email || `${guestname}@unchained.local`,
+          guest: true,
+          profile: {},
+          password: null,
+          initialPassword: true,
+          lastBillingAddress: {},
+        },
+        {},
+      );
+      return unchainedAPI.modules.users.findUserById(guestUserId);
+    },
+  };
+
+  accountsServer.on('LoginTokenCreated', async (props) => {
+    const { userId, connection = {} } = props;
+    const { userIdBeforeLogin, countryContext, remoteAddress, remotePort, userAgent, normalizedLocale } =
+      connection;
+
+    await unchainedAPI.modules.users.updateHeartbeat(userId, {
+      remoteAddress,
+      remotePort,
+      userAgent,
+      locale: normalizedLocale,
+      countryContext,
+    });
+
+    const user = await unchainedAPI.modules.users.findUserById(userId);
+    const context = {
+      ...unchainedAPI,
+      countryContext,
+      userId,
+      user,
+    };
+
+    if (userIdBeforeLogin) {
+      const userBeforeLogin = await unchainedAPI.modules.users.findUserById(userIdBeforeLogin);
+
+      await unchainedAPI.services.orders.migrateOrderCarts(
+        {
+          fromUser: userBeforeLogin,
+          toUser: user,
+          shouldMerge: accountsSettings.mergeUserCartsOnLogin,
+        },
+        context,
+      );
+
+      await unchainedAPI.services.bookmarks.migrateBookmarks(
+        {
+          fromUser: userBeforeLogin,
+          toUser: user,
+          shouldMerge: accountsSettings.mergeUserCartsOnLogin,
+        },
+        context,
+      );
+    }
+
+    await unchainedAPI.modules.orders.ensureCartForUser(
+      {
+        user,
+        countryCode: countryContext,
+      },
+      context,
+    );
+  });
+
+  accountsServer.on('ResetPasswordSuccess', async (user: User) => {
+    await unchainedAPI.modules.users.updateInitialPassword(user, false);
+  });
+
+  accountsServer.on('ChangePasswordSuccess', async (user: User) => {
+    await unchainedAPI.modules.users.updateInitialPassword(user, false);
+  });
+
+  accountsServer.on('ValidateLogin', async (params: { service: string; user: User }) => {
+    if (params.service !== 'guest' && params.user.guest) {
+      await unchainedAPI.modules.users.updateGuest(params.user, false);
+    }
+    return true;
+  });
+
+  return accountsServer;
+};

package/src/setup/setupAutoScheduling.ts

@@ -0,0 +1,5 @@
+import { configureGenerateOrderAutoscheduling } from '@unchainedshop/plugins/lib/worker/GenerateOrderWorker';
+
+export const setupAutoScheduling = () => {
+  configureGenerateOrderAutoscheduling();
+};

package/src/setup/setupCarts.ts

@@ -0,0 +1,27 @@
+import { Context } from '@unchainedshop/types/api';
+import { SetupCartsOptions } from '@unchainedshop/types/platform';
+
+const { UNCHAINED_DISABLE_PROVIDER_INVALIDATION, UNCHAINED_ASSIGN_CART_FOR_USERS } = process.env;
+
+export const setupCarts = async (unchainedAPI: Context, options: SetupCartsOptions = {}) => {
+  if (options.invalidateProviders ?? !UNCHAINED_DISABLE_PROVIDER_INVALIDATION) {
+    await unchainedAPI.modules.orders.invalidateProviders(
+      unchainedAPI,
+      options.providerInvalidationMaxAgeDays,
+    );
+  }
+
+  if (options.assignCartForUsers ?? Boolean(UNCHAINED_ASSIGN_CART_FOR_USERS)) {
+    const users = await unchainedAPI.modules.users.findUsers({});
+
+    await Promise.all(
+      users.map((user) => {
+        const locale = unchainedAPI.modules.users.userLocale(user);
+        return unchainedAPI.modules.orders.ensureCartForUser(
+          { user, countryCode: locale.country },
+          unchainedAPI,
+        );
+      }),
+    );
+  }
+};

package/src/setup/setupTemplates.ts

@@ -0,0 +1,17 @@
+import { MessageTypes } from '@unchainedshop/types/platform';
+import { MessagingDirector } from '@unchainedshop/core-messaging';
+import { resolveOrderRejectionTemplate } from '../templates/resolveOrderRejectionTemplate';
+import { resolveAccountActionTemplate } from '../templates/resolveAccountActionTemplate';
+import { resolveForwardDeliveryTemplate } from '../templates/resolveForwardDeliveryTemplate';
+import { resolveOrderConfirmationTemplate } from '../templates/resolveOrderConfirmationTemplate';
+import { resolveQuotationStatusTemplate } from '../templates/resolveQuotationStatusTemplate';
+import { resolveEnrollmentStatusTemplate } from '../templates/resolveEnrollmentStatusTemplate';
+
+export const setupTemplates = () => {
+  MessagingDirector.registerTemplate(MessageTypes.ACCOUNT_ACTION, resolveAccountActionTemplate);
+  MessagingDirector.registerTemplate(MessageTypes.DELIVERY, resolveForwardDeliveryTemplate);
+  MessagingDirector.registerTemplate(MessageTypes.ORDER_CONFIRMATION, resolveOrderConfirmationTemplate);
+  MessagingDirector.registerTemplate(MessageTypes.ORDER_REJECTION, resolveOrderRejectionTemplate);
+  MessagingDirector.registerTemplate(MessageTypes.QUOTATION_STATUS, resolveQuotationStatusTemplate);
+  MessagingDirector.registerTemplate(MessageTypes.ENROLLMENT_STATUS, resolveEnrollmentStatusTemplate);
+};

package/src/setup/setupWorkqueue.ts

@@ -0,0 +1,17 @@
+import { Context } from '@unchainedshop/types/api';
+import { SetupWorkqueueOptions } from '@unchainedshop/types/platform';
+import { EventListenerWorker, FailedRescheduler, IntervalWorker } from '@unchainedshop/core-worker';
+
+export const setupWorkqueue = (
+  unchainedAPI: Context,
+  { workerId, batchCount, schedule }: SetupWorkqueueOptions = {},
+) => {
+  const handlers = [
+    FailedRescheduler.actions(unchainedAPI),
+    EventListenerWorker.actions({ workerId }, unchainedAPI),
+    IntervalWorker.actions({ workerId, batchCount, schedule }, unchainedAPI),
+  ];
+
+  handlers.forEach((handler) => handler.start());
+  return handlers;
+};

package/src/startPlatform.ts

@@ -0,0 +1,145 @@
+import { SetupWorkqueueOptions, PlatformOptions, MessageTypes } from '@unchainedshop/types/platform';
+import { Meteor } from 'meteor/meteor';
+import { startAPIServer, roles } from '@unchainedshop/api';
+import { initCore } from '@unchainedshop/core';
+import { initDb } from '@unchainedshop/mongodb';
+import { createLogger } from '@unchainedshop/logger';
+import { createBulkImporterFactory } from './bulk-importer/createBulkImporter';
+import { runMigrations } from './migrations/runMigrations';
+import { generateEventTypeDefs } from './setup/generateEventTypeDefs';
+import { generateWorkerTypeDefs } from './setup/generateWorkTypeDefs';
+import { generateRoleActionTypeDefs } from './setup/generateRoleActionTypeDefs';
+import { setupAccounts } from './setup/setupAccounts';
+import { setupAutoScheduling } from './setup/setupAutoScheduling';
+import { setupCarts } from './setup/setupCarts';
+import { setupTemplates } from './setup/setupTemplates';
+import { setupWorkqueue } from './setup/setupWorkqueue';
+import { createMigrationRepository } from './migrations/migrationRepository';
+
+// Workers
+import '@unchainedshop/plugins/lib/worker/BulkImportWorker';
+import '@unchainedshop/plugins/lib/worker/ZombieKillerWorker';
+import '@unchainedshop/plugins/lib/worker/GenerateOrderWorker';
+import '@unchainedshop/plugins/lib/worker/MessageWorker';
+
+export { MessageTypes };
+
+const logger = createLogger('unchained');
+
+const REQUIRED_ENV_VARIABLES = ['EMAIL_WEBSITE_NAME', 'EMAIL_WEBSITE_URL', 'EMAIL_FROM'];
+
+const { NODE_ENV, UNCHAINED_DISABLE_WORKER } = process.env;
+
+const exitOnMissingEnvironmentVariables = () => {
+  const failedEnv = REQUIRED_ENV_VARIABLES.filter((key) => !process.env[key]);
+  if (failedEnv.length > 0) {
+    logger.error(`Missing required environment variables at boot time: ${failedEnv.join(', ')}`);
+    process.exit(1);
+  }
+};
+
+const checkWorkQueueEnabled = (options: SetupWorkqueueOptions) => {
+  if (options?.disableWorker) return false;
+  return !UNCHAINED_DISABLE_WORKER;
+};
+
+export const queueWorkers = [];
+
+export const startPlatform = async (
+  {
+    modules = {},
+    services = {},
+    typeDefs = [],
+    resolvers = [],
+    options = {},
+    rolesOptions = {},
+    bulkImporter: bulkImporterOptions,
+    schema,
+    plugins,
+    cache,
+    workQueueOptions,
+    context,
+    introspection,
+    playground,
+    tracing,
+    cacheControl,
+    corsOrigins,
+  }: PlatformOptions = {
+    modules: {},
+    services: {},
+    typeDefs: [],
+    resolvers: [],
+    options: {},
+  },
+) => {
+  exitOnMissingEnvironmentVariables();
+
+  // Configure database
+  const db = await initDb();
+
+  // Prepare Migrations
+  const migrationRepository = createMigrationRepository(db);
+  const bulkImporter = createBulkImporterFactory(db, bulkImporterOptions?.handlers);
+
+  // Initialise core api using the database
+  const unchainedAPI = await initCore({
+    db,
+    migrationRepository,
+    bulkImporter,
+    modules,
+    services,
+    options,
+  });
+
+  const isWorkQueueEnabled = checkWorkQueueEnabled(workQueueOptions);
+  if (isWorkQueueEnabled) {
+    await runMigrations({ migrationRepository, unchainedAPI });
+  }
+
+  const configuredRoles = roles.configureRoles(rolesOptions);
+
+  // Setup accountsjs specific extensions and event handlers
+  setupAccounts(unchainedAPI);
+
+  // Setup email templates
+  setupTemplates();
+
+  const generatedTypeDefs = [
+    ...generateEventTypeDefs(),
+    ...generateWorkerTypeDefs(),
+    ...generateRoleActionTypeDefs(),
+  ];
+
+  // Start the graphQL server
+  startAPIServer({
+    unchainedAPI,
+    roles: configuredRoles,
+    typeDefs: [...generatedTypeDefs, ...typeDefs],
+    resolvers,
+    schema,
+    plugins,
+    cache,
+    context,
+    introspection,
+    playground,
+    tracing,
+    corsOrigins,
+    cacheControl,
+  });
+
+  // Setup work queues for scheduled work
+  if (isWorkQueueEnabled) {
+    const handlers = setupWorkqueue(unchainedAPI, workQueueOptions);
+    handlers.forEach((handler) => queueWorkers.push(handler));
+    await setupCarts(unchainedAPI, workQueueOptions);
+
+    setupAutoScheduling();
+  }
+
+  // Setup filter cache
+  if (!options.filters?.skipInvalidationOnStartup) {
+    Meteor.defer(() => unchainedAPI.modules.filters.invalidateCache({}, unchainedAPI));
+  }
+
+  return unchainedAPI;
+};

package/src/templates/resolveAccountActionTemplate.ts

@@ -0,0 +1,144 @@
+import { TemplateResolver } from '@unchainedshop/types/messaging';
+
+const { EMAIL_FROM, EMAIL_WEBSITE_URL, EMAIL_WEBSITE_NAME } = process.env;
+
+const mjmlTemplate = `
+<mjml>
+  <mj-body background-color="#FAFAFA">
+      <mj-section padding-bottom="32px" background-color="#fcfcfc">
+        <mj-column width="100%">
+          <mj-text align="center" font-size="20px" color="#232323" font-family="Helvetica Neue" font-weight="200">
+            <h2>{{subject}}</h2>
+          </mj-text>
+          <mj-text align="left" font-size="20px" color="#232323" font-family="Helvetica Neue" font-weight="200">
+            <span>{{message}}</span><br/>
+          </mj-text>
+        </mj-column>
+      </mj-section>
+
+      <mj-section padding-bottom="20px" background-color="#f3f3f3">
+        <mj-column>
+          <mj-button href="{{url}}" font-family="Helvetica" background-color="#31302E" color="white">
+           {{buttonText}}
+         </mj-button>
+         <mj-spacer/>
+        </mj-column>
+      </mj-section>
+  </mj-body>
+</mjml>
+`;
+
+const verifyEmailEnglishConfig = {
+  buttonText: 'Verify email address',
+  message: 'We need to ensure that this email is yours as a commercial partner.',
+  subject: `${EMAIL_WEBSITE_NAME}: Verify your email address`,
+};
+
+const passwordChangedEmailEnglishConfig = {
+  message: `
+    Your account password has been successfully changed.\n
+  `,
+  subject: `${EMAIL_WEBSITE_NAME}: Your password has been changed`,
+};
+
+const textTemplate = `
+  {{message}}
+  {{#url}}
+  \n
+  -----------------\n
+  {{buttonText}}: {{url}}\n
+  -----------------\n
+  {{/url}}
+`;
+
+const emailConfig = {
+  'enroll-account': {
+    url: (token) => `${EMAIL_WEBSITE_URL}/enroll-account?token=${token}`,
+    en: {
+      buttonText: 'Set password',
+      message: `${EMAIL_WEBSITE_NAME} has set up an user account for you. Please click below to set up a password and to finish the registration.`,
+      subject: `${EMAIL_WEBSITE_NAME}: You got a new account`,
+    },
+    de: {
+      buttonText: 'Passwort setzen',
+      message: `${EMAIL_WEBSITE_NAME} hat für dich ein Benutzerkonto angelegt. Bitte klicke unten um ein Passwort zu setzen und damit die Registrierung abzuschliessen.`,
+      subject: `${EMAIL_WEBSITE_NAME}: Für dich wurde ein Konto eingerichtet`,
+    },
+    fr: {
+      buttonText: 'Set password',
+      message: `${EMAIL_WEBSITE_NAME} has set up an user account for you. Please click below to set up a password and to finish the registration.`,
+      subject: `${EMAIL_WEBSITE_NAME}: You got a new account`,
+    },
+  },
+  'reset-password': {
+    url: (token) => `${EMAIL_WEBSITE_URL}/reset-password?token=${token}`,
+    en: {
+      buttonText: 'Set new password',
+      message: `
+        Click on „Set new password". If you don’t want to set a new password, just ignore this email.\n
+      `,
+      subject: `${EMAIL_WEBSITE_NAME}: Set password`,
+    },
+    de: {
+      buttonText: 'Neues Passwort setzen',
+      message: `
+        Klicke auf „Neues Passwort setzen", um ein neues Passwort anzulegen.\n
+        Falls du dein Passwort nicht zurücksetzen möchtest, ignoriere dieses E-Mail einfach.\n
+      `,
+      subject: `${EMAIL_WEBSITE_NAME}: Passwort zurücksetzen`,
+    },
+    fr: {
+      buttonText: 'Set new password',
+      message: `
+        Click on „Set new password". If you don’t want to set a new password, just ignore this email.\n
+      `,
+      subject: `${EMAIL_WEBSITE_NAME}: Set password`,
+    },
+  },
+  'verify-email': {
+    url: (token) => `${EMAIL_WEBSITE_URL}/verify-email?token=${token}`,
+    en: verifyEmailEnglishConfig,
+    de: verifyEmailEnglishConfig,
+    fr: verifyEmailEnglishConfig,
+  },
+  '': {
+    // password changed!
+    url: () => null,
+    en: passwordChangedEmailEnglishConfig,
+    de: passwordChangedEmailEnglishConfig,
+    fr: passwordChangedEmailEnglishConfig,
+  },
+};
+
+export const resolveAccountActionTemplate: TemplateResolver = async (
+  { userId, action, recipientEmail, token },
+  { modules },
+) => {
+  if (!token || !action) return [];
+
+  const user = await modules.users.findUserById(userId);
+  const locale = modules.users.userLocale(user);
+
+  const { url } = emailConfig[action];
+  const { subject, message, buttonText } = emailConfig[action][locale.language];
+
+  const data = {
+    buttonText,
+    message,
+    subject,
+    url: url(token),
+  };
+
+  return [
+    {
+      type: 'EMAIL',
+      input: {
+        from: EMAIL_FROM || 'noreply@unchained.local',
+        to: recipientEmail || modules.users.primaryEmail(user)?.address,
+        subject,
+        text: modules.messaging.renderToText(textTemplate, data),
+        html: modules.messaging.renderMjmlToHtml(mjmlTemplate, data),
+      },
+    },
+  ];
+};

package/src/templates/resolveEnrollmentStatusTemplate.ts

@@ -0,0 +1,43 @@
+import { TemplateResolver } from '@unchainedshop/types/messaging';
+
+const { EMAIL_FROM, EMAIL_WEBSITE_NAME, EMAIL_WEBSITE_URL } = process.env;
+
+const textTemplate = `
+  {{subject}}\n
+  \n
+  Status: {{enrollment.status}}
+  \n
+  -----------------\n
+  Show: {{url}}\n
+  -----------------\n
+`;
+
+export const resolveEnrollmentStatusTemplate: TemplateResolver = async (
+  { enrollmentId, locale },
+  context,
+) => {
+  const { modules } = context;
+  const enrollment = await modules.enrollments.findEnrollment({ enrollmentId });
+  const user = await modules.users.findUserById(enrollment.userId);
+
+  const subject = `${EMAIL_WEBSITE_NAME}: Updated Enrollment / ${enrollment.enrollmentNumber}`;
+
+  const data = {
+    enrollment,
+    locale,
+    subject,
+    url: `${EMAIL_WEBSITE_URL}/enrollment?_id=${enrollment._id}`,
+  };
+
+  return [
+    {
+      type: 'EMAIL',
+      input: {
+        from: EMAIL_FROM || 'noreply@unchained.local',
+        to: modules.users.primaryEmail(user)?.address,
+        subject,
+        text: modules.messaging.renderToText(textTemplate, data),
+      },
+    },
+  ];
+};