@unchainedshop/core-users 1.1.3

package/src/module/configureUsersModule.ts

@@ -0,0 +1,342 @@
+import { Locale } from 'locale';
+import { ModuleInput, ModuleMutations, Query } from '@unchainedshop/types/common';
+import { User, UserQuery, UsersModule } from '@unchainedshop/types/user';
+import { log } from '@unchainedshop/logger';
+import { emit, registerEvents } from '@unchainedshop/events';
+import {
+  generateDbFilterById,
+  generateDbMutations,
+  Schemas,
+  systemLocale,
+} from '@unchainedshop/utils';
+import { FileDirector } from '@unchainedshop/file-upload';
+import { Context } from '@unchainedshop/types/api';
+import { UsersCollection } from '../db/UsersCollection';
+import addMigrations from './addMigrations';
+
+const USER_EVENTS = [
+  'USER_UPDATE',
+  'USER_UPDATE_PROFILE',
+  'USER_ADD_ROLES',
+  'USER_UPDATE_ROLE',
+  'USER_UPDATE_TAGS',
+  'USER_UPDATE_AVATAR',
+  'USER_UPDATE_HEARTBEAT',
+  'USER_UPDATE_BILLING_ADDRESS',
+  'USER_UPDATE_LAST_CONTACT',
+];
+const removeConfidentialServiceHashes = (rawUser: User): User => {
+  const user = rawUser;
+  delete user?.services;
+  return user;
+};
+
+const buildFindSelector = ({ includeGuests, queryString, ...rest }: UserQuery) => {
+  const selector: Query = { ...rest };
+  if (!includeGuests) selector.guest = { $ne: true };
+  if (queryString) {
+    selector.$text = { $search: queryString };
+  }
+  return selector;
+};
+
+const getUserLocale = (user: User, params: { localeContext?: Locale } = {}) => {
+  const locale =
+    params.localeContext ||
+    (user.lastLogin?.locale && new Locale(user.lastLogin.locale)) ||
+    systemLocale;
+  return locale;
+};
+
+FileDirector.registerFileUploadCallback('user-avatars', async (file, context: Context) => {
+  const { services } = context;
+
+  return services.users.updateUserAvatarAfterUpload({ file }, context);
+});
+
+export const configureUsersModule = async ({
+  db,
+  migrationRepository,
+}: ModuleInput<Record<string, never>>): Promise<UsersModule> => {
+  registerEvents(USER_EVENTS);
+  const Users = await UsersCollection(db);
+
+  // Migration
+  addMigrations(migrationRepository);
+
+  const mutations = generateDbMutations<User>(Users, Schemas.User) as ModuleMutations<User>;
+
+  return {
+    // Queries
+    count: async (query) => {
+      const userCount = await Users.countDocuments(buildFindSelector(query));
+      return userCount;
+    },
+
+    async findUserById(userId) {
+      if (!userId) return null;
+      return Users.findOne(generateDbFilterById(userId), {});
+    },
+
+    async findUserByToken({ resetToken, hashedToken }) {
+      if (hashedToken) {
+        return Users.findOne({
+          'services.resume.loginTokens.hashedToken': hashedToken,
+        });
+      }
+
+      if (resetToken) {
+        return Users.findOne({
+          'services.password.reset.token': resetToken,
+        });
+      }
+
+      return null;
+    },
+
+    findUser: async (query, options) => {
+      const selector = buildFindSelector(query);
+
+      return Users.findOne(selector, options);
+    },
+
+    findUsers: async ({ limit, offset, ...query }) => {
+      const selector = buildFindSelector(query);
+
+      if (query.queryString) {
+        return Users.find(selector, {
+          skip: offset,
+          limit,
+          projection: { score: { $meta: 'textScore' } },
+          sort: { score: { $meta: 'textScore' } },
+        }).toArray();
+      }
+
+      return Users.find(selector, { skip: offset, limit }).toArray();
+    },
+
+    userExists: async ({ userId }) => {
+      const selector = generateDbFilterById(userId);
+      const userCount = await Users.countDocuments(selector, { limit: 1 });
+      return !!userCount;
+    },
+
+    // Transformations
+    primaryEmail: (user) => {
+      return (user.emails || []).sort(
+        (left, right) => Number(right.verified) - Number(left.verified),
+      )?.[0];
+    },
+
+    userLocale: (user, params = {}) => {
+      return getUserLocale(user, params);
+    },
+
+    // Mutations
+    addRoles: async (userId, roles) => {
+      const selector = generateDbFilterById(userId);
+      const updateResult = await Users.updateOne(selector, {
+        $addToSet: { roles: { $each: roles } },
+      });
+
+      const user = await Users.findOne(selector, {});
+      emit('USER_ADD_ROLES', {
+        user: removeConfidentialServiceHashes(user),
+      });
+
+      return updateResult.modifiedCount;
+    },
+
+    updateAvatar: async (_id, fileId, userId) => {
+      const userFilter = generateDbFilterById(_id);
+      log('Update Avatar', { userId: _id });
+
+      const modifier = {
+        $set: {
+          avatarId: fileId,
+          updated: new Date(),
+          updatedBy: userId,
+        },
+      };
+
+      await mutations.update(_id, modifier, userId);
+      const user = await Users.findOne(userFilter, {});
+      emit('USER_UPDATE_AVATAR', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return user;
+    },
+
+    updateGuest: async (user, guest) => {
+      log('Update guest', { userId: user._id });
+
+      const modifier = { $set: { guest } };
+      await Users.updateOne(generateDbFilterById(user._id), modifier);
+    },
+
+    updateHeartbeat: async (userId, lastLogin) => {
+      const userFilter = generateDbFilterById(userId);
+
+      const modifier = {
+        $set: {
+          lastLogin: {
+            timestamp: new Date(),
+            ...lastLogin,
+          },
+        },
+      };
+
+      await mutations.update(userId, modifier, userId);
+      const user = await Users.findOne(userFilter, {});
+
+      emit('USER_UPDATE_HEARTBEAT', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return user;
+    },
+
+    updateInitialPassword: async (user, initialPassword) => {
+      log(`Update initial password flag to ${initialPassword}`, { userId: user._id, level: 'verbose' });
+
+      const modifier = { $set: { initialPassword } };
+      await Users.updateOne(generateDbFilterById(user._id), modifier);
+    },
+
+    updateProfile: async (_id, updatedData, userId) => {
+      const userFilter = generateDbFilterById(_id);
+      const { meta, profile } = updatedData;
+
+      if (!meta && !profile) {
+        return Users.findOne(userFilter, {});
+      }
+
+      const modifier = { $set: {} };
+
+      if (profile) {
+        modifier.$set = Object.keys(profile).reduce((acc, profileKey) => {
+          return {
+            ...acc,
+            [`profile.${profileKey}`]: profile[profileKey],
+          };
+        }, {});
+      }
+
+      if (meta) {
+        modifier.$set.meta = meta;
+      }
+
+      await mutations.update(_id, modifier, userId);
+      const user = await Users.findOne(userFilter, {});
+      emit('USER_UPDATE_PROFILE', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return user;
+    },
+
+    updateLastBillingAddress: async (_id, lastBillingAddress, userId) => {
+      const userFilter = generateDbFilterById(_id);
+      const user = await Users.findOne(userFilter, {});
+
+      log('Store Last Billing Address', { userId });
+
+      const modifier = {
+        $set: {
+          lastBillingAddress,
+          updated: new Date(),
+          updatedBy: userId,
+        },
+      };
+      const profile = user.profile || {};
+      const isGuest = !!user.guest;
+
+      if (!profile.displayName || isGuest) {
+        modifier.$set['profile.displayName'] = [
+          lastBillingAddress.firstName,
+          lastBillingAddress.lastName,
+        ]
+          .filter(Boolean)
+          .join(' ');
+      }
+
+      await mutations.update(_id, modifier, userId);
+      const updatedUser = await Users.findOne(userFilter, {});
+      emit('USER_UPDATE_BILLING_ADDRESS', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return updatedUser;
+    },
+
+    updateLastContact: async (_id, lastContact, userId) => {
+      const userFilter = generateDbFilterById(_id);
+      const user = await Users.findOne(userFilter, {});
+
+      log('Store Last Contact', { userId });
+
+      const profile = user.profile || {};
+      const isGuest = !!user.guest;
+
+      const modifier = {
+        $set: {
+          updated: new Date(),
+          updatedBy: userId,
+          lastContact,
+        },
+      };
+
+      if ((!profile.phoneMobile || isGuest) && lastContact.telNumber) {
+        // Backport the contact phone number to the user profile
+        modifier.$set['profile.phoneMobile'] = lastContact.telNumber;
+      }
+
+      await mutations.update(_id, modifier, userId);
+      const updatedUser = await Users.findOne(userFilter, {});
+      emit('USER_UPDATE_LAST_CONTACT', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return updatedUser;
+    },
+
+    updateRoles: async (_id, roles, userId) => {
+      const userFilter = generateDbFilterById(_id);
+
+      const modifier = {
+        $set: {
+          updated: new Date(),
+          updateBy: userId,
+          roles,
+        },
+      };
+      await mutations.update(_id, modifier, userId);
+      const user = await Users.findOne(userFilter, {});
+      emit('USER_UPDATE_ROLE', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return user;
+    },
+    updateTags: async (_id, tags, userId) => {
+      const userFilter = generateDbFilterById(_id);
+
+      const modifier = {
+        $set: {
+          updated: new Date(),
+          updateBy: userId,
+          tags,
+        },
+      };
+
+      await mutations.update(_id, modifier, userId);
+      const user = await Users.findOne(userFilter, {});
+      emit('USER_UPDATE_TAGS', {
+        user: removeConfidentialServiceHashes(user),
+      });
+      return user;
+    },
+    updateUser: async (query, modifier, options) => {
+      await Users.updateOne(query, modifier, options);
+      const user = await Users.findOne(query);
+      emit('USER_UPDATE', {
+        user: removeConfidentialServiceHashes(user),
+      });
+    },
+  };
+};

package/src/services/getUserCountryService.ts

@@ -0,0 +1,9 @@
+import { GetUserCountryService } from '@unchainedshop/types/user';
+
+export const getUserCountryService: GetUserCountryService = async (user, params, { modules }) => {
+  const userLocale = modules.users.userLocale(user, params);
+
+  return modules.countries.findCountry({
+    isoCode: userLocale.country.toUpperCase(),
+  });
+};

package/src/services/getUserLanguageService.ts

@@ -0,0 +1,9 @@
+import { GetUserLanguageService } from '@unchainedshop/types/user';
+
+export const getUserLanguageService: GetUserLanguageService = async (user, params, { modules }) => {
+  const userLocale = modules.users.userLocale(user, params);
+
+  return modules.languages.findLanguage({
+    isoCode: userLocale.language,
+  });
+};

package/src/services/getUserRoleActionsService.ts

@@ -0,0 +1,29 @@
+import { GetUserRoleActionsService } from '@unchainedshop/types/user';
+import { Roles } from '@unchainedshop/roles';
+
+const permissions = async (userRoles: any, allRoles: any) => {
+  const actions = userRoles?.flatMap((role) => {
+    const foundRole: any = Object.values(allRoles).find((r: any) => r.name === role);
+    if (!foundRole) return [];
+    return Object.entries(foundRole.allowRules || {}).flatMap(([roleName, funcs]: any) => {
+      return funcs.map(async (f) => {
+        try {
+          // return permissions that are by default activated for that role,
+          // accidentally don't check context
+          const r = await f(null, null, null);
+          if (r) return roleName;
+          return null;
+        } catch (e) {
+          return null;
+        }
+      });
+    });
+  });
+  const resolvedActions = await Promise.all(actions);
+  return [...new Set(resolvedActions)].filter(Boolean).sort((a: any, b: any) => a.localeCompare(b));
+};
+
+export const getUserRoleActionsService: GetUserRoleActionsService = async (user, context) => {
+  const userRoles = Roles.getUserRoles(user?._id, user.roles, true);
+  return permissions(userRoles, context.roles) as Promise<string[]>;
+};

package/src/services/updateUserAvatarAfterUploadService.ts

@@ -0,0 +1,21 @@
+import { UpdateUserAvatarAfterUploadService } from '@unchainedshop/types/user';
+
+export const updateUserAvatarAfterUploadService: UpdateUserAvatarAfterUploadService = async (
+  { file },
+  context,
+) => {
+  const { modules, services, userId: currentUserId } = context;
+  const { userId } = file.meta as { userId: string };
+  const user = await modules.users.findUserById(userId);
+
+  if (user?.avatarId) {
+    await services.files.removeFiles(
+      {
+        fileIds: [user.avatarId as string],
+      },
+      context,
+    );
+  }
+
+  await modules.users.updateAvatar(userId, file._id, currentUserId || file.updatedBy || file.createdBy);
+};

package/src/services/userServices.ts

@@ -0,0 +1,12 @@
+import { UserServices } from '@unchainedshop/types/user';
+import { getUserCountryService } from './getUserCountryService';
+import { getUserLanguageService } from './getUserLanguageService';
+import { getUserRoleActionsService } from './getUserRoleActionsService';
+import { updateUserAvatarAfterUploadService } from './updateUserAvatarAfterUploadService';
+
+export const userServices: UserServices = {
+  getUserCountry: getUserCountryService,
+  getUserLanguage: getUserLanguageService,
+  getUserRoleActions: getUserRoleActionsService,
+  updateUserAvatarAfterUpload: updateUserAvatarAfterUploadService,
+};

package/src/users-index.ts

@@ -0,0 +1,3 @@
+export { configureUsersModule } from './module/configureUsersModule';
+
+export { userServices } from './services/userServices';

package/tests/users-index.test.ts

@@ -0,0 +1,47 @@
+import { assert } from 'chai';
+import { initDb } from 'meteor/unchained:mongodb';
+import { configureUsersModule } from 'meteor/unchained:core-users';
+import { UsersModule } from '@unchainedshop/types/user';
+import { Db } from '@unchainedshop/types/common';
+
+describe('Test exports', () => {
+  let module: UsersModule;
+  let db: Db;
+  let userId: string;
+
+  before(async () => {
+    db = await initDb();
+    module = await configureUsersModule({ db });
+    assert.ok(module);
+  });
+  before(async () => {
+    const Users = db.collection('users');
+    await Users.deleteMany({});
+    const insertResult = await Users.insertOne({
+      emails: [],
+      username: 'test.user',
+      lastLogin: {},
+      profile: {
+        displayName: 'Test User',
+        birthday: new Date('1995-01-12'),
+        phoneMobile: '+41701231212',
+        gender: 'Male',
+      },
+      guest: false,
+      tags: [],
+      services: {},
+      roles: ['admin'],
+    });
+
+    userId = insertResult.insertedId.toHexString();
+  });
+
+  it('Check queries', async () => {
+    assert.isTrue(await module.userExists({ userId }));
+    assert.isFalse(await module.userExists({ userId: '123123133123ABCD' }));
+    assert.equal(await module.count({ queryString: 'Test' }), 1);
+    assert.equal(await module.count({ queryString: 'Urrghh' }), 0);
+    assert.ok(await module.findUserById(userId));
+    assert.lengthOf(await module.findUsers({ limit: 10 }), 1);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": ["node"],
+    "baseUrl": ".", // This must be specified if "paths" is.
+    "paths": {
+      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node", "mocha"]
+  },
+  "include": ["src", "tests"]
+}