@flink-app/generic-auth-plugin 0.3.0 → 0.3.1

package/.flink/generatedHandlers.ts

@@ -1,4 +1,4 @@
-// Generated Fri Nov 19 2021 11:09:05 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:01 GMT+0100 (Central European Standard Time)
 import { autoRegisteredHandlers, HttpMethod } from "@flink-app/flink";
 import * as UserCreate_0 from "../src/handlers/UserCreate";
 import * as UserLogin_0 from "../src/handlers/UserLogin";

package/.flink/generatedRepos.ts

@@ -1,4 +1,4 @@
-// Generated Fri Nov 19 2021 11:09:05 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:01 GMT+0100 (Central European Standard Time)
   import { autoRegisteredRepos } from "@flink-app/flink";
   export const repos = [];
   autoRegisteredRepos.push(...repos);

package/.flink/schemas/schemas.ts

@@ -27,7 +27,7 @@ import { PutManagementUserRolesByUseridRes } from "../../src/schemas/Management/
 import { PutManagementUserUsernameByUseridReq } from "../../src/schemas/Management/PutUserUsernameByUseridReq";
 import { PutManagementUserUsernameByUseridRes } from "../../src/schemas/Management/PutUserUsernameByUseridRes";
 
-// Generated Fri Nov 19 2021 11:09:07 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:03 GMT+0100 (Central European Standard Time)
 export interface UserCreate_13_ReqSchema extends UserCreateReq {}
 
 export interface UserCreate_13_ResSchema extends UserCreateRes {}

package/.flink/start.ts

@@ -1,4 +1,4 @@
-// Generated Fri Nov 19 2021 11:09:06 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:01 GMT+0100 (Central European Standard Time)
 import "./generatedHandlers";
 import "./generatedRepos";
 import "../src/index";

package/dist/.flink/generatedHandlers.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlers = void 0;
-// Generated Fri Nov 19 2021 11:09:05 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:01 GMT+0100 (Central European Standard Time)
 var flink_1 = require("@flink-app/flink");
 exports.handlers = [];
 flink_1.autoRegisteredHandlers.push.apply(flink_1.autoRegisteredHandlers, exports.handlers);

package/dist/.flink/generatedRepos.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.repos = void 0;
-// Generated Fri Nov 19 2021 11:09:05 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:01 GMT+0100 (Central European Standard Time)
 var flink_1 = require("@flink-app/flink");
 exports.repos = [];
 flink_1.autoRegisteredRepos.push.apply(flink_1.autoRegisteredRepos, exports.repos);

package/dist/.flink/start.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// Generated Fri Nov 19 2021 11:09:06 GMT+0100 (Central European Standard Time)
+// Generated Fri Dec 03 2021 10:39:01 GMT+0100 (Central European Standard Time)
 require("./generatedHandlers");
 require("./generatedRepos");
 require("../src/index");

package/dist/src/coreFunctions.js

@@ -87,7 +87,7 @@ function createUser(repo, auth, username, password, authentificationMethod, role
                             }];
                     }
                     userData = {
-                        username: username,
+                        username: username.toLowerCase(),
                         roles: roles,
                         profile: profile,
                         authentificationMethod: authentificationMethod,
@@ -281,7 +281,7 @@ function passwordResetComplete(repo, auth, jwtSecret, passwordResetToken, code,
                     payload = { type: "", username: "" };
                     try {
                         secret = jwtSecret + ":" + code;
-                        payload = (jsonwebtoken_1.default.verify(passwordResetToken, secret));
+                        payload = jsonwebtoken_1.default.verify(passwordResetToken, secret);
                     }
                     catch (ex) {
                         return [2 /*return*/, { status: "invalidCode" }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flink-app/generic-auth-plugin",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Flink plugin that provides a generic user authentification solution.",
   "scripts": {
     "test": "echo \"Error: no test specified\"",
@@ -29,5 +29,5 @@
     "ts-node": "^9.1.1",
     "typescript": "^4.2.4"
   },
-  "gitHead": "21b4a23ed4d3eea816c38271bd37b5aa9d91cd5b"
+  "gitHead": "95140d0eaa2c17a8f6214c44fe5dda057585af82"
 }

package/src/coreFunctions.ts

@@ -11,314 +11,289 @@ import { UserPasswordResetCompleteRes } from "./schemas/UserPasswordResetComplet
 
 import jsonwebtoken from "jsonwebtoken";
 
-export function getJtwTokenPlugin(
-  secret: string,
-  rolePermissions?: { [role: string]: string[] },
-  passwordPolicy?: RegExp
-) {
-  if (passwordPolicy == undefined) {
-    passwordPolicy = /.{1,}$/;
-  }
-  if (rolePermissions == undefined) {
-    rolePermissions = {};
-  }
-  if (rolePermissions["user"] == null) {
-    rolePermissions["user"] = [];
-  }
-  if (!rolePermissions["user"].includes("authenticated"))
-    rolePermissions["user"].push("authenticated");
-
-  return jwtAuthPlugin({
-    secret,
-    getUser: (tokenData: any) => {
-      return new Promise<FlinkAuthUser>((res) => {
-        res({
-          username: tokenData.username,
-          _id: tokenData._id,
-        });
-      });
-    },
-    passwordPolicy,
-    rolePermissions,
-  });
+export function getJtwTokenPlugin(secret: string, rolePermissions?: { [role: string]: string[] }, passwordPolicy?: RegExp) {
+    if (passwordPolicy == undefined) {
+        passwordPolicy = /.{1,}$/;
+    }
+    if (rolePermissions == undefined) {
+        rolePermissions = {};
+    }
+    if (rolePermissions["user"] == null) {
+        rolePermissions["user"] = [];
+    }
+    if (!rolePermissions["user"].includes("authenticated")) rolePermissions["user"].push("authenticated");
+
+    return jwtAuthPlugin({
+        secret,
+        getUser: (tokenData: any) => {
+            return new Promise<FlinkAuthUser>((res) => {
+                res({
+                    username: tokenData.username,
+                    _id: tokenData._id,
+                });
+            });
+        },
+        passwordPolicy,
+        rolePermissions,
+    });
 }
 
 export async function createUser(
-  repo: FlinkRepo<any, User>,
-  auth: JwtAuthPlugin,
-  username: string,
-  password: string,
-  authentificationMethod: "password" | "sms",
-  roles: string[],
-  profile: UserProfile,
-  createPasswordHashAndSaltMethod?: {
-    (password: string): Promise<{ hash: string; salt: string } | null>;
-  }
+    repo: FlinkRepo<any, User>,
+    auth: JwtAuthPlugin,
+    username: string,
+    password: string,
+    authentificationMethod: "password" | "sms",
+    roles: string[],
+    profile: UserProfile,
+    createPasswordHashAndSaltMethod?: {
+        (password: string): Promise<{ hash: string; salt: string } | null>;
+    }
 ): Promise<UserCreateRes> {
-  if (!roles.includes("user")) roles.push("user");
+    if (!roles.includes("user")) roles.push("user");
 
-  const existingUser = await repo.getOne({ username: username.toLowerCase() });
-  if (existingUser != null) {
-    return {
-      status: "userExists",
-    };
-  }
-  let userData: Omit<User, "_id"> = {
-    username,
-    roles,
-    profile,
-    authentificationMethod,
-    pushNotificationTokens: [],
-  };
-
-  if (authentificationMethod == "password") {
-    let passwordAndSalt = null;
-    if (createPasswordHashAndSaltMethod != null) {
-      passwordAndSalt = await createPasswordHashAndSaltMethod(password);
-    } else {
-      passwordAndSalt = await auth.createPasswordHashAndSalt(password);
+    const existingUser = await repo.getOne({ username: username.toLowerCase() });
+    if (existingUser != null) {
+        return {
+            status: "userExists",
+        };
     }
+    let userData: Omit<User, "_id"> = {
+        username: username.toLowerCase(),
+        roles,
+        profile,
+        authentificationMethod,
+        pushNotificationTokens: [],
+    };
 
-    if (passwordAndSalt == null) {
-      return {
-        status: "passwordError",
-      };
+    if (authentificationMethod == "password") {
+        let passwordAndSalt = null;
+        if (createPasswordHashAndSaltMethod != null) {
+            passwordAndSalt = await createPasswordHashAndSaltMethod(password);
+        } else {
+            passwordAndSalt = await auth.createPasswordHashAndSalt(password);
+        }
+
+        if (passwordAndSalt == null) {
+            return {
+                status: "passwordError",
+            };
+        }
+        userData.password = passwordAndSalt.hash;
+        userData.salt = passwordAndSalt.salt;
     }
-    userData.password = passwordAndSalt.hash;
-    userData.salt = passwordAndSalt.salt;
-  }
-
-  const user = await repo.create(userData);
-
-  const token = await auth.createToken(
-    { username: username.toLowerCase(), _id: user._id },
-    roles
-  );
-
-  return {
-    status: "success",
-    user: {
-      _id: user._id,
-      token: token,
-      username: username.toLowerCase(),
-    },
-  };
+
+    const user = await repo.create(userData);
+
+    const token = await auth.createToken({ username: username.toLowerCase(), _id: user._id }, roles);
+
+    return {
+        status: "success",
+        user: {
+            _id: user._id,
+            token: token,
+            username: username.toLowerCase(),
+        },
+    };
 }
 
 export async function loginUser(
-  repo: FlinkRepo<any, User>,
-  auth: JwtAuthPlugin,
-  username: string,
-  password: string | undefined,
-  validatePasswordMethod?: {
-    (password: string, hash: string, salt: string): Promise<boolean>;
-  }
+    repo: FlinkRepo<any, User>,
+    auth: JwtAuthPlugin,
+    username: string,
+    password: string | undefined,
+    validatePasswordMethod?: {
+        (password: string, hash: string, salt: string): Promise<boolean>;
+    }
 ): Promise<UserLoginRes> {
-  const user = await repo.getOne({ username: username.toLowerCase() });
-  if (user == null) {
-    return { status: "failed" };
-  }
-
-  let valid: boolean = false;
-
-  if (user.authentificationMethod == "password") {
-    if (password == null) password = "";
-
-    if (validatePasswordMethod != null) {
-      valid = await validatePasswordMethod(
-        password,
-        <string>user.password,
-        <string>user.salt
-      );
-
-      //If not valid, try to use default auth
-      if (!valid) {
-        try {
-          valid = await auth.validatePassword(
-            password,
-            <string>user.password,
-            <string>user.salt
-          );
-        } catch (ex) {}
-      }
-    } else {
-      valid = await auth.validatePassword(
-        password,
-        <string>user.password,
-        <string>user.salt
-      );
+    const user = await repo.getOne({ username: username.toLowerCase() });
+    if (user == null) {
+        return { status: "failed" };
     }
-  }
-  if (user.authentificationMethod == "sms") {
-    log.error("SMS login is not yet impleted.");
-    return { status: "failed" };
-  }
-
-  if (valid) {
-    const token = await auth.createToken(
-      { username: username.toLowerCase(), _id: user._id },
-      user.roles
-    );
 
-    return {
-      status: "success",
-      user: {
-        _id: user._id,
-        username: user.username,
-        token,
-        profile: user.profile,
-      },
-    };
-  } else {
-    return { status: "failed" };
-  }
+    let valid: boolean = false;
+
+    if (user.authentificationMethod == "password") {
+        if (password == null) password = "";
+
+        if (validatePasswordMethod != null) {
+            valid = await validatePasswordMethod(password, <string>user.password, <string>user.salt);
+
+            //If not valid, try to use default auth
+            if (!valid) {
+                try {
+                    valid = await auth.validatePassword(password, <string>user.password, <string>user.salt);
+                } catch (ex) {}
+            }
+        } else {
+            valid = await auth.validatePassword(password, <string>user.password, <string>user.salt);
+        }
+    }
+    if (user.authentificationMethod == "sms") {
+        log.error("SMS login is not yet impleted.");
+        return { status: "failed" };
+    }
+
+    if (valid) {
+        const token = await auth.createToken({ username: username.toLowerCase(), _id: user._id }, user.roles);
+
+        return {
+            status: "success",
+            user: {
+                _id: user._id,
+                username: user.username,
+                token,
+                profile: user.profile,
+            },
+        };
+    } else {
+        return { status: "failed" };
+    }
 }
 
 export async function changePassword(
-  repo: FlinkRepo<any, User>,
-  auth: JwtAuthPlugin,
-  userId: string,
-  newPassword: string,
-  createPasswordHashAndSaltMethod?: {
-    (password: string): Promise<{ hash: string; salt: string } | null>;
-  }
+    repo: FlinkRepo<any, User>,
+    auth: JwtAuthPlugin,
+    userId: string,
+    newPassword: string,
+    createPasswordHashAndSaltMethod?: {
+        (password: string): Promise<{ hash: string; salt: string } | null>;
+    }
 ): Promise<UserPasswordChangeRes> {
-  const user = await repo.getById(userId);
-  if (user == null) {
-    return { status: "failed" };
-  }
+    const user = await repo.getById(userId);
+    if (user == null) {
+        return { status: "failed" };
+    }
 
-  if (user.authentificationMethod != "password") {
-    return { status: "failed" };
-  }
+    if (user.authentificationMethod != "password") {
+        return { status: "failed" };
+    }
 
-  let passwordAndSalt = null;
+    let passwordAndSalt = null;
 
-  if (createPasswordHashAndSaltMethod == null) {
-    passwordAndSalt = await auth.createPasswordHashAndSalt(newPassword);
-  } else {
-    passwordAndSalt = await createPasswordHashAndSaltMethod(newPassword);
-  }
+    if (createPasswordHashAndSaltMethod == null) {
+        passwordAndSalt = await auth.createPasswordHashAndSalt(newPassword);
+    } else {
+        passwordAndSalt = await createPasswordHashAndSaltMethod(newPassword);
+    }
 
-  if (passwordAndSalt == null) {
-    return {
-      status: "passwordError",
-    };
-  }
+    if (passwordAndSalt == null) {
+        return {
+            status: "passwordError",
+        };
+    }
 
-  await repo.updateOne(userId, {
-    password: passwordAndSalt.hash,
-    salt: passwordAndSalt.salt,
-  });
+    await repo.updateOne(userId, {
+        password: passwordAndSalt.hash,
+        salt: passwordAndSalt.salt,
+    });
 
-  return { status: "success" };
+    return { status: "success" };
 }
 
 export async function passwordResetStart(
-  repo: FlinkRepo<any, User>,
-  auth: JwtAuthPlugin,
-  jwtSecret: string,
-  username: string,
-  numberOfDigits?: number,
-  lifeTime?: string
+    repo: FlinkRepo<any, User>,
+    auth: JwtAuthPlugin,
+    jwtSecret: string,
+    username: string,
+    numberOfDigits?: number,
+    lifeTime?: string
 ): Promise<UserPasswordResetStartRes> {
-  const user = await repo.getOne({ username: username.toLowerCase() });
-  if (user == null) {
-    return { status: "userNotFound" };
-  }
-
-  if (user.authentificationMethod != "password") {
-    return { status: "userNotFound" };
-  }
-
-  if (numberOfDigits == null) numberOfDigits = 6;
-  if (lifeTime == null) lifeTime = "1h";
-
-  const payload = {
-    type: "passwordReset",
-    username: username.toLocaleLowerCase(),
-  };
-  const code = generate(numberOfDigits);
-
-  const secret = jwtSecret + ":" + code;
-
-  const options: jsonwebtoken.SignOptions = {
-    expiresIn: lifeTime,
-  };
-
-  const token = jsonwebtoken.sign(payload, secret, options);
-
-  return {
-    status: "success",
-    passwordResetToken: token,
-    code,
-    profile: user.profile,
-  };
-}
+    const user = await repo.getOne({ username: username.toLowerCase() });
+    if (user == null) {
+        return { status: "userNotFound" };
+    }
+
+    if (user.authentificationMethod != "password") {
+        return { status: "userNotFound" };
+    }
+
+    if (numberOfDigits == null) numberOfDigits = 6;
+    if (lifeTime == null) lifeTime = "1h";
+
+    const payload = {
+        type: "passwordReset",
+        username: username.toLocaleLowerCase(),
+    };
+    const code = generate(numberOfDigits);
 
-export async function passwordResetComplete(
-  repo: FlinkRepo<any, User>,
-  auth: JwtAuthPlugin,
-  jwtSecret: string,
-  passwordResetToken: string,
-  code: string,
-  newPassword: string,
-  createPasswordHashAndSaltMethod?: {
-    (password: string): Promise<{ hash: string; salt: string } | null>;
-  }
-): Promise<UserPasswordResetCompleteRes> {
-  let payload: { type: string; username: string } = { type: "", username: "" };
-  try {
     const secret = jwtSecret + ":" + code;
-    payload = <{ type: string; username: string }>(
-      jsonwebtoken.verify(passwordResetToken, secret)
-    );
-  } catch (ex) {
-    return { status: "invalidCode" };
-  }
-
-  const user = await repo.getOne({ username: payload.username });
-  if (user == null) {
-    return { status: "userNotFound" };
-  }
-
-  if (user.authentificationMethod != "password") {
-    return { status: "userNotFound" };
-  }
-
-  let passwordAndSalt = null;
-
-  if (createPasswordHashAndSaltMethod == null) {
-    passwordAndSalt = await auth.createPasswordHashAndSalt(newPassword);
-  } else {
-    passwordAndSalt = await createPasswordHashAndSaltMethod(newPassword);
-  }
-
-  if (passwordAndSalt == null) {
+
+    const options: jsonwebtoken.SignOptions = {
+        expiresIn: lifeTime,
+    };
+
+    const token = jsonwebtoken.sign(payload, secret, options);
+
     return {
-      status: "passwordError",
+        status: "success",
+        passwordResetToken: token,
+        code,
+        profile: user.profile,
     };
-  }
+}
 
-  await repo.updateOne(user._id, {
-    password: passwordAndSalt.hash,
-    salt: passwordAndSalt.salt,
-  });
+export async function passwordResetComplete(
+    repo: FlinkRepo<any, User>,
+    auth: JwtAuthPlugin,
+    jwtSecret: string,
+    passwordResetToken: string,
+    code: string,
+    newPassword: string,
+    createPasswordHashAndSaltMethod?: {
+        (password: string): Promise<{ hash: string; salt: string } | null>;
+    }
+): Promise<UserPasswordResetCompleteRes> {
+    let payload: { type: string; username: string } = { type: "", username: "" };
+    try {
+        const secret = jwtSecret + ":" + code;
+        payload = <{ type: string; username: string }>jsonwebtoken.verify(passwordResetToken, secret);
+    } catch (ex) {
+        return { status: "invalidCode" };
+    }
+
+    const user = await repo.getOne({ username: payload.username });
+    if (user == null) {
+        return { status: "userNotFound" };
+    }
+
+    if (user.authentificationMethod != "password") {
+        return { status: "userNotFound" };
+    }
+
+    let passwordAndSalt = null;
 
-  return { status: "success" };
+    if (createPasswordHashAndSaltMethod == null) {
+        passwordAndSalt = await auth.createPasswordHashAndSalt(newPassword);
+    } else {
+        passwordAndSalt = await createPasswordHashAndSaltMethod(newPassword);
+    }
+
+    if (passwordAndSalt == null) {
+        return {
+            status: "passwordError",
+        };
+    }
+
+    await repo.updateOne(user._id, {
+        password: passwordAndSalt.hash,
+        salt: passwordAndSalt.salt,
+    });
+
+    return { status: "success" };
 }
 
 function generate(n: number): string {
-  var add = 1,
-    max = 12 - add;
+    var add = 1,
+        max = 12 - add;
 
-  if (n > max) {
-    return generate(max) + generate(n - max);
-  }
+    if (n > max) {
+        return generate(max) + generate(n - max);
+    }
 
-  max = Math.pow(10, n + add);
-  var min = max / 10;
-  var number = Math.floor(Math.random() * (max - min + 1)) + min;
+    max = Math.pow(10, n + add);
+    var min = max / 10;
+    var number = Math.floor(Math.random() * (max - min + 1)) + min;
 
-  return ("" + number).substring(add);
+    return ("" + number).substring(add);
 }