@proteinjs/user-server 1.1.4 → 1.2.0

package/src/services/Signup.ts

@@ -0,0 +1,230 @@
+import { getDb, getDbAsSystem } from '@proteinjs/db';
+import {
+  SendInviteResponse,
+  tables,
+  UserAuth,
+  uiRoutes,
+  SignupService,
+  InitializeSignupResponse,
+  UserRepo,
+  Invite,
+  UserSignup,
+} from '@proteinjs/user';
+import moment from 'moment';
+import { lib } from 'crypto-js';
+import { Logger } from '@proteinjs/util';
+import {
+  EmailSender,
+  getDefaultInviteEmailConfigFactory,
+  getDefaultSignupConfirmationEmailConfigFactory,
+} from '@proteinjs/email-server';
+import sha256 from 'crypto-js/sha256';
+import { Loadable, SourceRepository } from '@proteinjs/reflection';
+
+export interface InviteConfig {
+  isInviteOnly: boolean;
+}
+
+export interface DefaultInviteConfigFactory extends Loadable {
+  getConfig(): InviteConfig;
+}
+
+export const getDefaultInviteConfigFactory = (): DefaultInviteConfigFactory => {
+  const defaultFactory: DefaultInviteConfigFactory = {
+    getConfig: (): InviteConfig => ({ isInviteOnly: false }),
+  };
+
+  const factory = SourceRepository.get().object<DefaultInviteConfigFactory>(
+    '@proteinjs/user-server/DefaultInviteConfigFactory'
+  );
+  return factory || defaultFactory;
+};
+
+export class Signup implements SignupService {
+  public serviceMetadata = {
+    auth: {
+      canAccess: (methodName: string, args: any[]) => {
+        if (methodName === 'sendInvite' || methodName === 'revokeInvite') {
+          UserAuth.hasRole('admin');
+        }
+
+        return true;
+      },
+    },
+  };
+
+  async createUser(user: UserSignup, token?: string): Promise<void> {
+    const logger = new Logger('SignupService: createUser');
+    const db = getDbAsSystem();
+
+    const initSignupResponse = await this.initializeSignup(token);
+    if (!initSignupResponse.isReady) {
+      throw new Error(initSignupResponse.error);
+    }
+
+    const invite = token ? await this.getValidInvite(token) : null;
+    if (token) {
+      await db.delete(tables.Invite, { token });
+    }
+
+    const email = invite ? invite.email : user.email;
+    if (!email) {
+      throw new Error('Email is required when there is no invite');
+    }
+
+    const defaultEmailConfigFactory = getDefaultSignupConfirmationEmailConfigFactory();
+    const config = defaultEmailConfigFactory.getConfig();
+    const emailSender = new EmailSender();
+
+    const userRecord = await db.get(tables.User, { email });
+    if (userRecord) {
+      logger.error(`User with this email already exists: ${email}`);
+      const { text, html } = config.getExistingUserEmailContent();
+      await emailSender.sendEmail({
+        to: email,
+        subject: config.existingUserSubject || config.options?.subject || 'Account already exists',
+        text,
+        html,
+        ...config.options,
+      });
+      return;
+    }
+
+    await db.insert(tables.User, {
+      name: user.name,
+      email,
+      password: sha256(user.password).toString(),
+      emailVerified: false,
+      roles: '',
+      invitedBy: invite ? invite.invitedBy : null,
+    });
+
+    const { text, html } = config.getNewUserEmailContent();
+    await emailSender.sendEmail({
+      to: email,
+      subject: config.newUserSubject || config.options?.subject || 'Welcome!',
+      text,
+      html,
+      ...config.options,
+    });
+    logger.info(`Created user: ${email}`);
+  }
+
+  async sendInvite(email: string): Promise<SendInviteResponse> {
+    const logger = new Logger('SignupService: sendInvite');
+    try {
+      const db = getDbAsSystem();
+      const userRecord = await db.get(tables.User, { email });
+      if (userRecord) {
+        return { sent: false, error: 'User already exists with that email.' };
+      }
+
+      const emailSender = new EmailSender();
+      const defaultConfigFactory = getDefaultInviteEmailConfigFactory();
+      if (!defaultConfigFactory) {
+        throw new Error(
+          `Unable to find a @proteinjs/email-server/DefaultInviteEmailConfigFactory implementation when sending invite.`
+        );
+      }
+      const config = defaultConfigFactory.getConfig();
+
+      const token = lib.WordArray.random(32).toString();
+      const tokenExpiresAt = moment().add(7, 'days');
+      let invite = await db.get(tables.Invite, { email });
+      if (invite) {
+        invite = {
+          ...invite,
+          token,
+          tokenExpiresAt,
+        };
+        await db.update(tables.Invite, invite);
+      } else {
+        const userId = new UserRepo().getUser().id;
+        invite = await db.insert(tables.Invite, { email, token, tokenExpiresAt, invitedBy: userId });
+      }
+
+      const { text, html } = config.getEmailContent(`${uiRoutes.auth.signup}?token=${token}`);
+      await emailSender.sendEmail({
+        to: email,
+        subject: config.options?.subject || `You're Invited`,
+        text,
+        html,
+        ...config.options,
+      });
+
+      return { sent: true };
+    } catch (error: any) {
+      logger.error('Error: ', error);
+      return {
+        sent: false,
+        error: 'Error occurred.',
+      };
+    }
+  }
+
+  async revokeInvite(email: string): Promise<void> {
+    if (!email) {
+      throw new Error('No email was provided.');
+    }
+
+    const db = getDb();
+    await db.delete(tables.Invite, { email });
+  }
+
+  /**
+   * Initializes signup process, validating invite configuration and token if provided.
+   * `DefaultInviteConfigFactory` defaults to invite optional.
+   */
+  async initializeSignup(inviteToken: string | undefined): Promise<InitializeSignupResponse> {
+    try {
+      const config = getDefaultInviteConfigFactory().getConfig();
+      const { isInviteOnly } = config;
+      const invite = inviteToken ? await this.getValidInvite(inviteToken) : undefined;
+
+      if (isInviteOnly) {
+        if (!inviteToken) {
+          return {
+            isReady: false,
+            error: 'An invite is required to sign up.',
+            isInviteOnly,
+          };
+        }
+        if (!invite) {
+          return {
+            isReady: false,
+            error: 'The provided invite was not found or has expired.',
+            isInviteOnly,
+          };
+        }
+      }
+
+      return {
+        isReady: true,
+        isInviteOnly,
+        invite: invite ? invite : undefined,
+      };
+    } catch (error: any) {
+      return {
+        isReady: false,
+        error: 'Initializing sign up failed.',
+      };
+    }
+  }
+
+  /** Returns a valid invite if it exists and is not expired, returns `null` otherwise. */
+  private async getValidInvite(token: string): Promise<Invite | null> {
+    const db = getDbAsSystem();
+    const invite = await db.get(tables.Invite, { token });
+
+    if (!invite) {
+      return null;
+    }
+
+    const currentTime = moment();
+    if (invite.tokenExpiresAt && moment(invite.tokenExpiresAt).isBefore(currentTime)) {
+      return null;
+    }
+
+    return invite;
+  }
+}

package/dist/src/routes/createUser.d.ts

@@ -1,3 +0,0 @@
-import { Route } from '@proteinjs/server-api';
-export declare const createUser: Route;
-//# sourceMappingURL=createUser.d.ts.map

package/dist/src/routes/createUser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createUser.d.ts","sourceRoot":"","sources":["../../../src/routes/createUser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAK9C,eAAO,MAAM,UAAU,EAAE,KAyBxB,CAAC"}

package/dist/src/routes/createUser.js

@@ -1,83 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUser = void 0;
-var sha256_1 = __importDefault(require("crypto-js/sha256"));
-var db_1 = require("@proteinjs/db");
-var user_1 = require("@proteinjs/user");
-var util_1 = require("@proteinjs/util");
-exports.createUser = {
-    path: user_1.routes.createUser.path,
-    method: user_1.routes.createUser.method,
-    onRequest: function (request, response) { return __awaiter(void 0, void 0, void 0, function () {
-        var logger, user, db, userRecord, error;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    logger = new util_1.Logger('createUser');
-                    user = request.body;
-                    db = (0, db_1.getDbAsSystem)();
-                    return [4 /*yield*/, db.get(user_1.tables.User, { email: user.email })];
-                case 1:
-                    userRecord = _a.sent();
-                    if (userRecord) {
-                        error = "User with this email already exists";
-                        console.error("".concat(error, ": ").concat(user.email));
-                        response.send({ error: error });
-                        return [2 /*return*/];
-                    }
-                    return [4 /*yield*/, db.insert(user_1.tables.User, {
-                            name: user.name,
-                            email: user.email,
-                            password: (0, sha256_1.default)(user.password).toString(),
-                            emailVerified: false,
-                            roles: '',
-                        })];
-                case 2:
-                    _a.sent();
-                    logger.info("Created user: ".concat(user.email));
-                    response.send({});
-                    return [2 /*return*/];
-            }
-        });
-    }); },
-};
-//# sourceMappingURL=createUser.js.map

package/dist/src/routes/createUser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createUser.js","sourceRoot":"","sources":["../../../src/routes/createUser.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4DAAsC;AAEtC,oCAA8C;AAC9C,wCAAuD;AACvD,wCAAyC;AAE5B,QAAA,UAAU,GAAU;IAC/B,IAAI,EAAE,aAAM,CAAC,UAAU,CAAC,IAAI;IAC5B,MAAM,EAAE,aAAM,CAAC,UAAU,CAAC,MAAM;IAChC,SAAS,EAAE,UAAO,OAAO,EAAE,QAAQ;;;;;oBAC3B,MAAM,GAAG,IAAI,aAAM,CAAC,YAAY,CAAC,CAAC;oBAClC,IAAI,GAAG,OAAO,CAAC,IAAY,CAAC;oBAC5B,EAAE,GAAG,IAAA,kBAAa,GAAE,CAAC;oBACR,qBAAM,EAAE,CAAC,GAAG,CAAC,aAAM,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,EAAA;;oBAA7D,UAAU,GAAG,SAAgD;oBACnE,IAAI,UAAU,EAAE;wBACR,KAAK,GAAG,qCAAqC,CAAC;wBACpD,OAAO,CAAC,KAAK,CAAC,UAAG,KAAK,eAAK,IAAI,CAAC,KAAK,CAAE,CAAC,CAAC;wBACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,OAAA,EAAE,CAAC,CAAC;wBACzB,sBAAO;qBACR;oBAED,qBAAM,EAAE,CAAC,MAAM,CAAC,aAAM,CAAC,IAAI,EAAE;4BAC3B,IAAI,EAAE,IAAI,CAAC,IAAI;4BACf,KAAK,EAAE,IAAI,CAAC,KAAK;4BACjB,QAAQ,EAAE,IAAA,gBAAM,EAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE;4BAC1C,aAAa,EAAE,KAAK;4BACpB,KAAK,EAAE,EAAE;yBACV,CAAC,EAAA;;oBANF,SAME,CAAC;oBACH,MAAM,CAAC,IAAI,CAAC,wBAAiB,IAAI,CAAC,KAAK,CAAE,CAAC,CAAC;oBAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;;;;SACnB;CACF,CAAC"}

package/src/routes/createUser.ts

@@ -1,32 +0,0 @@
-import sha256 from 'crypto-js/sha256';
-import { Route } from '@proteinjs/server-api';
-import { getDbAsSystem } from '@proteinjs/db';
-import { User, tables, routes } from '@proteinjs/user';
-import { Logger } from '@proteinjs/util';
-
-export const createUser: Route = {
-  path: routes.createUser.path,
-  method: routes.createUser.method,
-  onRequest: async (request, response): Promise<void> => {
-    const logger = new Logger('createUser');
-    const user = request.body as User;
-    const db = getDbAsSystem();
-    const userRecord = await db.get(tables.User, { email: user.email });
-    if (userRecord) {
-      const error = `User with this email already exists`;
-      console.error(`${error}: ${user.email}`);
-      response.send({ error });
-      return;
-    }
-
-    await db.insert(tables.User, {
-      name: user.name,
-      email: user.email,
-      password: sha256(user.password).toString(),
-      emailVerified: false,
-      roles: '',
-    });
-    logger.info(`Created user: ${user.email}`);
-    response.send({});
-  },
-};