mifi/auth-db
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Restructuring the folders #1

Merged
mifi merged 8 commits from develop into main 2023-05-24 16:48:48 +00:00
Conversation 0 Commits 8 Files Changed 44 +482 -553
36 changed files with 482 additions and 553 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 35b89062e4 - Show all commits

19
.eslintrc.js Normal file
View File

@@ -0,0 +1,19 @@
/* eslint-env node */
module.exports = {
extends: [
'eslint:recommended',
'plugin:@typescript-eslint/recommended',
'plugin:import/errors',
'plugin:prettier/recommended',
'prettier',
],
parser: '@typescript-eslint/parser',
plugins: ['@typescript-eslint'],
settings: {
'import/parsers': {
'@typescript-eslint/parser': ['.ts', '.tsx'],
},
'import/resolver': 'typescript',
},
root: true,
};

11
.npmignore
View File

@@ -1,8 +1,9 @@
.build.yarnrc.yml
.drone.yml
.prettierrc
.yarnrc.yml
babel.config.*
jest.config.*
src src
tsconfig.json tsconfig.json
tslint.json tslint.json
.prettierrc
.yarnrc.yml
.drone.yml
babel.config.*
jest.config.*

7
.prettierrc.js Normal file
View File

@@ -0,0 +1,7 @@
module.exports = {
parser: 'typescript',
printWidth: 120,
trailingComma: 'all',
tabWidth: 4,
singleQuote: true,
};

6
src/api/authenticate.ts
View File

@@ -1,6 +1,6 @@
import { Auth, Log } from ".."; import { Auth, Log } from '..';
import { Action } from "../constants/action"; import { Action } from '../constants/action';
import { getLoginToken } from "../utils/getLoginToken"; import { getLoginToken } from '../utils/getLoginToken';
export const authenticate = async (username: string, password: string) => { export const authenticate = async (username: string, password: string) => {
const doc = await Auth.findByUsername(username).catch(); const doc = await Auth.findByUsername(username).catch();

4
src/api/deleteStrategy.ts
View File

@@ -1,5 +1,5 @@
import { StringSchemaDefinition } from "mongoose"; import { StringSchemaDefinition } from 'mongoose';
import { Auth, Strategy } from ".."; import { Auth, Strategy } from '..';
export const deleteStrategy = async (id: StringSchemaDefinition) => { export const deleteStrategy = async (id: StringSchemaDefinition) => {
const strategy = await Strategy.findById(id); const strategy = await Strategy.findById(id);

8
src/api/resetPasswordGet.ts
View File

@@ -1,7 +1,7 @@
import { readOneByUsername } from "../dao/readOneByUsername"; import { readOneByUsername } from '../dao/readOneByUsername';
import { Log, Token } from ".."; import { Log, Token } from '..';
import { TokenType } from "../constants/tokens"; import { TokenType } from '../constants/tokens';
import { Action } from "../constants/action"; import { Action } from '../constants/action';
export const resetPasswordGet = async (username: string) => { export const resetPasswordGet = async (username: string) => {
const doc = await readOneByUsername(username); const doc = await readOneByUsername(username);

14
src/api/resetPasswordPost.ts
View File

@@ -1,11 +1,11 @@
import { Types } from "mongoose"; import { Types } from 'mongoose';
import { Log, Strategy, Token } from ".."; import { Log, Strategy, Token } from '..';
import { STRATEGIES } from "../constants/strategies"; import { STRATEGIES } from '../constants/strategies';
import { AuthDocument } from "../schema/auth"; import { AuthDocument } from '../schema/auth';
import { getLoginToken } from "../utils/getLoginToken"; import { getLoginToken } from '../utils/getLoginToken';
import { StrategyDocument } from "../schema/strategy"; import { StrategyDocument } from '../schema/strategy';
import { Action } from "../constants/action"; import { Action } from '../constants/action';
export const resetPasswordPost = async (token: string, password: string) => { export const resetPasswordPost = async (token: string, password: string) => {
const parentId = await Token.validateResetToken(token); const parentId = await Token.validateResetToken(token);

14
src/constants/action.ts
View File

@@ -1,9 +1,9 @@
export enum Action { export enum Action {
AUTHENTICATE = "AUTHENTICATE", AUTHENTICATE = 'AUTHENTICATE',
AUTHENTICATE_FAILURE = "AUTHENTICATE_FAILURE", AUTHENTICATE_FAILURE = 'AUTHENTICATE_FAILURE',
CREATE = "CREATE", CREATE = 'CREATE',
DELETE = "DELETE", DELETE = 'DELETE',
RESET = "RESET", RESET = 'RESET',
RESET_REQUEST = "RESET_REQUEST", RESET_REQUEST = 'RESET_REQUEST',
UPDATE = "UPDATE", UPDATE = 'UPDATE',
} }

8
src/constants/db.ts
View File

@@ -4,7 +4,7 @@ export const DB_USERNAME = process.env.DB_USERNAME;
export const DB_PASSWORD = process.env.DB_PASSWORD; export const DB_PASSWORD = process.env.DB_PASSWORD;
export const DB_NAME = process.env.DB_NAME; export const DB_NAME = process.env.DB_NAME;
export const COLL_AUTH = "Auth"; export const COLL_AUTH = 'Auth';
export const COLL_LOG = "Log"; export const COLL_LOG = 'Log';
export const COLL_STRATEGY = "Strategy"; export const COLL_STRATEGY = 'Strategy';
export const COLL_TOKEN = "Token"; export const COLL_TOKEN = 'Token';

23
src/constants/env.ts
View File

@@ -1,21 +1,20 @@
export const PACKAGE_NAME = "@mifi/auth"; export const PACKAGE_NAME = '@mifi/auth';
export const PORT = process.env.PORT || 9000; export const PORT = process.env.PORT || 9000;
export const SESSION_KEY = process.env.SESSION_KEY || "secret-key"; export const SESSION_KEY = process.env.SESSION_KEY || 'secret-key';
export const JWT_AUDIENCE = process.env.JWT_AUDIENCE || "mifi.dev"; export const JWT_AUDIENCE = process.env.JWT_AUDIENCE || 'mifi.dev';
export const JWT_ISSUER = process.env.JWT_ISSUER || PACKAGE_NAME; export const JWT_ISSUER = process.env.JWT_ISSUER || PACKAGE_NAME;
export const JWT_SECRET = process.env.JWT_SECRET || "secret"; export const JWT_SECRET = process.env.JWT_SECRET || 'secret';
export const LOGIN_VALID_TIMEOUT = process.env.LOGIN_VALID_TIMEOUT || "12h"; // ###d|h|m export const LOGIN_VALID_TIMEOUT = process.env.LOGIN_VALID_TIMEOUT || '12h'; // ###d|h|m
export const RESET_VALID_TIMEOUT = process.env.RESET_VALID_TIMEOUT || "15m"; // ###d|h|m export const RESET_VALID_TIMEOUT = process.env.RESET_VALID_TIMEOUT || '15m'; // ###d|h|m
export const VERIFY_VALID_TIMEOUT = process.env.VERIFY_VALID_TIMEOUT || "60d"; // ###d|h|m export const VERIFY_VALID_TIMEOUT = process.env.VERIFY_VALID_TIMEOUT || '60d'; // ###d|h|m
export const DEFAULT_TOKEN_DAYS = process.env.DEFAULT_TOKEN_DAYS || 365; export const DEFAULT_TOKEN_DAYS = process.env.DEFAULT_TOKEN_DAYS || 365;
export const ROUTE_PREFIX = process.env.ROUTE_PREFIX || "/auth"; export const ROUTE_PREFIX = process.env.ROUTE_PREFIX || '/auth';
export const LOGIN_ROUTE = process.env.LOGIN_ROUTE || "/login"; export const LOGIN_ROUTE = process.env.LOGIN_ROUTE || '/login';
export const RESET_ROUTE = process.env.RESET_ROUTE || "/reset"; export const RESET_ROUTE = process.env.RESET_ROUTE || '/reset';
export const VERIFICATION_ROUTE = export const VERIFICATION_ROUTE = process.env.VERIFICATION_ROUTE || '/verification';
process.env.VERIFICATION_ROUTE || "/verification";
export const REQUIRE_VERIFICATION = process.env.REQUIRE_VERIFICATION || true; export const REQUIRE_VERIFICATION = process.env.REQUIRE_VERIFICATION || true;

5
src/constants/errors.ts
View File

@@ -1,10 +1,9 @@
export enum ErrorCodes { export enum ErrorCodes {
RESET_REQUEST_DATA = "RESET_REQUEST_DATA", RESET_REQUEST_DATA = 'RESET_REQUEST_DATA',
} }
export const ErrorMessages = { export const ErrorMessages = {
[ErrorCodes.RESET_REQUEST_DATA]: [ErrorCodes.RESET_REQUEST_DATA]: 'A valid username and password must be provided',
"A valid username and password must be provided",
}; };
export const getErrorBody = (code: ErrorCodes) => ({ export const getErrorBody = (code: ErrorCodes) => ({

4
src/constants/tokens.ts
View File

@@ -1,4 +1,4 @@
export enum TokenType { export enum TokenType {
RESET = "RESET", RESET = 'RESET',
VERIFICATION = "VERIFICATION", VERIFICATION = 'VERIFICATION',
} }

32
src/dao/create.ts
View File

@@ -1,25 +1,21 @@
import { DatabaseError } from "@mifi/services-common/lib/domain/errors/DatabaseError"; import { DatabaseError } from '@mifi/services-common/lib/domain/errors/DatabaseError';
import { Auth, Log, Strategy, Token } from ".."; import { Auth, Log, Strategy, Token } from '..';
import { Auth as AuthProps } from "../schema/auth"; import { Auth as AuthProps } from '../schema/auth';
import { STRATEGIES } from "../constants/strategies"; import { STRATEGIES } from '../constants/strategies';
import { REQUIRE_VERIFICATION } from "../constants/env"; import { REQUIRE_VERIFICATION } from '../constants/env';
import { TokenType } from "../constants/tokens"; import { TokenType } from '../constants/tokens';
import { Status } from "../constants/auth"; import { Status } from '../constants/auth';
import { Action } from "../constants/action"; import { Action } from '../constants/action';
export const create = async ({ export const create = async ({ record, username, password }: AuthProps & { password: string }) => {
record,
username,
password,
}: AuthProps & { password: string }) => {
const status = REQUIRE_VERIFICATION ? Status.UNVERIFIED : Status.ACTIVE; const status = REQUIRE_VERIFICATION ? Status.UNVERIFIED : Status.ACTIVE;
const doc = await Auth.create({ const doc = await Auth.create({
record, record,
status, status,
username, username,
}).catch((err) => { }).catch((err) => {
throw new DatabaseError("failed to create user", { err }); throw new DatabaseError('failed to create user', { err });
}); });
if (doc) { if (doc) {
const strategy = await Strategy.create({ const strategy = await Strategy.create({
@@ -27,7 +23,7 @@ export const create = async ({
key: password, key: password,
parent: doc._id, parent: doc._id,
}).catch((err) => { }).catch((err) => {
throw new DatabaseError("failed to create strategy", { err }); throw new DatabaseError('failed to create strategy', { err });
}); });
if (strategy) { if (strategy) {
doc.strategies.push(strategy._id); doc.strategies.push(strategy._id);
@@ -35,13 +31,11 @@ export const create = async ({
Log.add(doc._id, Action.CREATE); Log.add(doc._id, Action.CREATE);
return { return {
doc, doc,
token: token: REQUIRE_VERIFICATION && (await Token.getToken(TokenType.VERIFICATION, doc._id)),
REQUIRE_VERIFICATION &&
(await Token.getToken(TokenType.VERIFICATION, doc._id)),
}; };
} }
await doc.deleteOne((err) => { await doc.deleteOne((err) => {
throw new DatabaseError("failed to remove invalid auth record", { throw new DatabaseError('failed to remove invalid auth record', {
err, err,
doc, doc,
}); });

8
src/dao/deleteById.ts
View File

@@ -1,8 +1,8 @@
import { StringSchemaDefinition } from "mongoose"; import { StringSchemaDefinition } from 'mongoose';
import { Auth, Log, Strategy, Token } from ".."; import { Auth, Log, Strategy, Token } from '..';
import { Status } from "../constants/auth"; import { Status } from '../constants/auth';
import { Action } from "../constants/action"; import { Action } from '../constants/action';
export const deleteById = async (id: StringSchemaDefinition) => { export const deleteById = async (id: StringSchemaDefinition) => {
if ( if (

14
src/dao/readAll.ts
View File

@@ -1,11 +1,9 @@
import { FilterQuery } from "mongoose"; import { FilterQuery } from 'mongoose';
import { Auth } from "../model/auth"; import { Auth } from '../model/auth';
import { Status } from "../constants/auth"; import { Status } from '../constants/auth';
import { AuthDocument } from "../schema/auth"; import { AuthDocument } from '../schema/auth';
export const readAll = async (query: FilterQuery<AuthDocument> = {}) => export const readAll = async (query: FilterQuery<AuthDocument> = {}) => Auth.find(query);
Auth.find(query);
export const readAllActive = async () => export const readAllActive = async () => readAll({ status: { $ne: Status.DELETED } });
readAll({ status: { $ne: Status.DELETED } });

4
src/dao/readOneById.ts
View File

@@ -1,5 +1,5 @@
import { Types } from "mongoose"; import { Types } from 'mongoose';
import { Auth } from "../model/auth"; import { Auth } from '../model/auth';
export const readOneById = async (id: Types.ObjectId) => Auth.findById(id); export const readOneById = async (id: Types.ObjectId) => Auth.findById(id);

7
src/dao/readOneByRecord.ts
View File

@@ -1,6 +1,5 @@
import { Types } from "mongoose"; import { Types } from 'mongoose';
import { Auth } from "../model/auth"; import { Auth } from '../model/auth';
export const readOneByRecord = async (record: Types.ObjectId) => export const readOneByRecord = async (record: Types.ObjectId) => Auth.findOne({ record });
Auth.findOne({ record });

5
src/dao/readOneByUsername.ts
View File

@@ -1,4 +1,3 @@
import { Auth } from "../model/auth"; import { Auth } from '../model/auth';
export const readOneByUsername = async (username: string) => export const readOneByUsername = async (username: string) => Auth.findOne({ username });
Auth.findOne({ username });

28
src/index.ts
View File

@@ -1,26 +1,16 @@
import mongoose from "mongoose"; import mongoose from 'mongoose';
import { import { DB_HOST, DB_NAME, DB_PASSWORD, DB_PORT, DB_USERNAME } from './constants/db';
DB_HOST, import { Auth } from './model/auth';
DB_NAME, import { Log } from './model/log';
DB_PASSWORD, import { Strategy } from './model/strategy';
DB_PORT, import { Token } from './model/token';
DB_USERNAME,
} from "./constants/db";
import { Auth } from "./model/auth";
import { Log } from "./model/log";
import { Strategy } from "./model/strategy";
import { Token } from "./model/token";
const connection = mongoose const connection = mongoose
.connect( .connect(`mongodb://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}`)
`mongodb://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}` .then((c) => console.debug('Database connection established', { connection: c }))
)
.then((c) =>
console.debug("Database connection established", { connection: c })
)
.catch((error) => { .catch((error) => {
console.error("Mongo connection failure", error); console.error('Mongo connection failure', error);
process.exit(1); process.exit(1);
}); });

11
src/model/auth.ts
View File

@@ -1,9 +1,6 @@
import mongoose from "mongoose"; import mongoose from 'mongoose';
import { AuthDocument, AuthModel, AuthSchema } from "../schema/auth"; import { AuthDocument, AuthModel, AuthSchema } from '../schema/auth';
import { COLL_AUTH } from "../constants/db"; import { COLL_AUTH } from '../constants/db';
export const Auth = mongoose.model<AuthDocument, AuthModel>( export const Auth = mongoose.model<AuthDocument, AuthModel>(COLL_AUTH, AuthSchema);
COLL_AUTH,
AuthSchema
);

6
src/model/log.ts
View File

@@ -1,6 +1,6 @@
import mongoose from "mongoose"; import mongoose from 'mongoose';
import { LogModel, Log as LogDocument, LogSchema } from "../schema/log"; import { LogModel, Log as LogDocument, LogSchema } from '../schema/log';
import { COLL_LOG } from "../constants/db"; import { COLL_LOG } from '../constants/db';
export const Log = mongoose.model<LogDocument, LogModel>(COLL_LOG, LogSchema); export const Log = mongoose.model<LogDocument, LogModel>(COLL_LOG, LogSchema);

15
src/model/strategy.ts
View File

@@ -1,13 +1,6 @@
import mongoose from "mongoose"; import mongoose from 'mongoose';
import { import { StrategyDocument, StrategyModel, StrategySchema } from '../schema/strategy';
StrategyDocument, import { COLL_STRATEGY } from '../constants/db';
StrategyModel,
StrategySchema,
} from "../schema/strategy";
import { COLL_STRATEGY } from "../constants/db";
export const Strategy = mongoose.model<StrategyDocument, StrategyModel>( export const Strategy = mongoose.model<StrategyDocument, StrategyModel>(COLL_STRATEGY, StrategySchema);
COLL_STRATEGY,
StrategySchema
);

15
src/model/token.ts
View File

@@ -1,13 +1,6 @@
import mongoose from "mongoose"; import mongoose from 'mongoose';
import { import { TokenModel, Token as TokenDocument, TokenSchema } from '../schema/token';
TokenModel, import { COLL_TOKEN } from '../constants/db';
Token as TokenDocument,
TokenSchema,
} from "../schema/token";
import { COLL_TOKEN } from "../constants/db";
export const Token = mongoose.model<TokenDocument, TokenModel>( export const Token = mongoose.model<TokenDocument, TokenModel>(COLL_TOKEN, TokenSchema);
COLL_TOKEN,
TokenSchema
);

40
src/schema/auth.ts
View File

@@ -1,17 +1,10 @@
import { import { Document, InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';
Document,
InferSchemaType,
Model,
Schema,
StringSchemaDefinition,
Types,
} from "mongoose";
import { Status } from "../constants/auth"; import { Status } from '../constants/auth';
import { COLL_STRATEGY } from "../constants/db"; import { COLL_STRATEGY } from '../constants/db';
import { STRATEGIES } from "../constants/strategies"; import { STRATEGIES } from '../constants/strategies';
import { StrategyDocument } from "./strategy"; import { StrategyDocument } from './strategy';
import { verify } from "../utils/password"; import { verify } from '../utils/password';
export interface Auth { export interface Auth {
is2FA?: boolean; is2FA?: boolean;
@@ -56,28 +49,17 @@ export const AuthSchema = new Schema<AuthDocument, AuthModel>(
{ {
minimize: true, minimize: true,
timestamps: true, timestamps: true,
} },
); );
AuthSchema.methods.authenticate = async function ( AuthSchema.methods.authenticate = async function (this: AuthBaseDocument, password: string) {
this: AuthBaseDocument,
password: string
) {
const strategy = await this.getStrategy(); const strategy = await this.getStrategy();
return !!strategy && verify(password, strategy.key); return !!strategy && verify(password, strategy.key);
}; };
AuthSchema.methods.getStrategy = async function ( AuthSchema.methods.getStrategy = async function (this: AuthBaseDocument, method = STRATEGIES.LOCAL) {
this: AuthBaseDocument, const doc = await this.populate<{ strategies: StrategyDocument[] }>('strategies');
method = STRATEGIES.LOCAL return doc.strategies.filter((strategy) => strategy.method === method).pop() || null;
) {
const doc = await this.populate<{ strategies: StrategyDocument[] }>(
"strategies"
);
return (
doc.strategies.filter((strategy) => strategy.method === method).pop() ||
null
);
}; };
AuthSchema.statics = { AuthSchema.statics = {

14
src/schema/log.ts
View File

@@ -1,14 +1,8 @@
import { import { InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';
InferSchemaType,
Model,
Schema,
StringSchemaDefinition,
Types,
} from "mongoose";
import { Payload } from "@mifi/services-common/lib/types/Payload"; import { Payload } from '@mifi/services-common/lib/types/Payload';
import { Action } from "../constants/action"; import { Action } from '../constants/action';
export interface Log { export interface Log {
action: Action; action: Action;
@@ -31,7 +25,7 @@ export const LogSchema = new Schema<Log, LogModel>(
{ {
minimize: true, minimize: true,
timestamps: true, timestamps: true,
} },
); );
LogSchema.statics = { LogSchema.statics = {

37
src/schema/strategy.ts
View File

@@ -1,17 +1,10 @@
import { import { Document, InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';
Document,
InferSchemaType,
Model,
Schema,
StringSchemaDefinition,
Types,
} from "mongoose";
import { STRATEGIES } from "../constants/strategies"; import { STRATEGIES } from '../constants/strategies';
import { encrypt } from "../utils/password"; import { encrypt } from '../utils/password';
import { COLL_AUTH } from "../constants/db"; import { COLL_AUTH } from '../constants/db';
import { AuthDocument } from "./auth"; import { AuthDocument } from './auth';
import { Strategy } from ".."; import { Strategy } from '..';
export interface Strategy { export interface Strategy {
method: STRATEGIES; method: STRATEGIES;
@@ -57,31 +50,27 @@ export const StrategySchema = new Schema<StrategyDocument, StrategyModel>(
{ {
minimize: true, minimize: true,
timestamps: true, timestamps: true,
} },
); );
StrategySchema.methods.getPopulatedStrategy = async function ( StrategySchema.methods.getPopulatedStrategy = async function (this: StrategyDocument) {
this: StrategyDocument return this.populate<StrategyPopulatedDocument>('parent');
) {
return this.populate<StrategyPopulatedDocument>("parent");
}; };
StrategySchema.methods.getAuthRecord = async function (this: StrategyDocument) { StrategySchema.methods.getAuthRecord = async function (this: StrategyDocument) {
return (await this.getPopulatedStrategy()).parent; return (await this.getPopulatedStrategy()).parent;
}; };
StrategySchema.pre("save", async function save(next) { StrategySchema.pre('save', async function save(next) {
if (typeof this.method === "undefined") { if (typeof this.method === 'undefined') {
return next(new Error(`Strategy requires a method.`)); return next(new Error(`Strategy requires a method.`));
} }
if (await Strategy.findOne({ method: this.method, parent: this.parent })) { if (await Strategy.findOne({ method: this.method, parent: this.parent })) {
return next( return next(new Error(`${this.method} strategy already exists for this user.`));
new Error(`${this.method} strategy already exists for this user.`)
);
} }
if (this.method !== STRATEGIES.LOCAL || !this.isModified("key")) { if (this.method !== STRATEGIES.LOCAL || !this.isModified('key')) {
return next(); return next();
} }

22
src/schema/token.ts
View File

@@ -1,14 +1,8 @@
import { import { InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';
InferSchemaType,
Model,
Schema,
StringSchemaDefinition,
Types,
} from "mongoose";
import { TokenType } from "../constants/tokens"; import { TokenType } from '../constants/tokens';
import { getDefaultExpiresFor } from "../utils/getDefaultExpiresFor"; import { getDefaultExpiresFor } from '../utils/getDefaultExpiresFor';
import { sign, verify } from "../utils/jwt"; import { sign, verify } from '../utils/jwt';
export interface Token { export interface Token {
auth: StringSchemaDefinition; auth: StringSchemaDefinition;
@@ -31,7 +25,7 @@ export const TokenSchema = new Schema<Token, TokenModel>(
{ {
minimize: true, minimize: true,
timestamps: true, timestamps: true,
} },
); );
TokenSchema.statics = { TokenSchema.statics = {
@@ -42,11 +36,7 @@ TokenSchema.statics = {
return { success: acknowledged, deletedCount }; return { success: acknowledged, deletedCount };
}, },
async getToken( async getToken(type: TokenType, auth: StringSchemaDefinition, expires?: number) {
type: TokenType,
auth: StringSchemaDefinition,
expires?: number
) {
const existing = await this.findOne({ type, auth }); const existing = await this.findOne({ type, auth });
if (existing) { if (existing) {
await existing.deleteOne(); await existing.deleteOne();

10
src/utils/getDefaultExpiresFor.ts
View File

@@ -1,10 +1,6 @@
import { import { LOGIN_VALID_TIMEOUT, RESET_VALID_TIMEOUT, VERIFY_VALID_TIMEOUT } from '../constants/env';
LOGIN_VALID_TIMEOUT, import { TokenType } from '../constants/tokens';
RESET_VALID_TIMEOUT, import { parseTimeoutToMs } from '../utils/parseTimeoutToMs';
VERIFY_VALID_TIMEOUT,
} from "../constants/env";
import { TokenType } from "../constants/tokens";
import { parseTimeoutToMs } from "../utils/parseTimeoutToMs";
export const getDefaultExpiresFor = (type: TokenType | void) => { export const getDefaultExpiresFor = (type: TokenType | void) => {
if (type === TokenType.RESET) { if (type === TokenType.RESET) {

8
src/utils/getLoginToken.ts
View File

@@ -1,7 +1,7 @@
import { sign } from "../utils/jwt"; import { sign } from '../utils/jwt';
import { LOGIN_VALID_TIMEOUT } from "../constants/env"; import { LOGIN_VALID_TIMEOUT } from '../constants/env';
import { parseTimeoutToMs } from "../utils/parseTimeoutToMs"; import { parseTimeoutToMs } from '../utils/parseTimeoutToMs';
import { AuthDocument } from "../schema/auth"; import { AuthDocument } from '../schema/auth';
export const getLoginToken = ({ record: sub, status }: AuthDocument) => export const getLoginToken = ({ record: sub, status }: AuthDocument) =>
sign({ sign({

14
src/utils/jwt.ts
View File

@@ -1,5 +1,5 @@
import jwt from "jsonwebtoken"; import jwt from 'jsonwebtoken';
import { JWT_AUDIENCE, JWT_ISSUER, JWT_SECRET } from "../constants/env"; import { JWT_AUDIENCE, JWT_ISSUER, JWT_SECRET } from '../constants/env';
export interface TokenProps { export interface TokenProps {
aud?: string; aud?: string;
exp?: number | Date; exp?: number | Date;
@@ -13,15 +13,11 @@ export type SignProps = string | TokenProps | void;
export const sign = (props: SignProps) => { export const sign = (props: SignProps) => {
const today = new Date(); const today = new Date();
const { sub = null, ...rest }: TokenProps = const { sub = null, ...rest }: TokenProps =
typeof props === "string" || typeof props === "undefined" typeof props === 'string' || typeof props === 'undefined' ? { sub: props || null } : props;
? { sub: props || null }
: props;
let { exp } = rest; let { exp } = rest;
if (!exp) { if (!exp) {
exp = new Date(today); exp = new Date(today);
exp.setDate( exp.setDate(today.getDate() + parseInt(process.env.JWT_DAYS_VALID as string));
today.getDate() + parseInt(process.env.JWT_DAYS_VALID as string)
);
exp = exp.getTime() / 1000; exp = exp.getTime() / 1000;
} }
return jwt.sign( return jwt.sign(
@@ -32,7 +28,7 @@ export const sign = (props: SignProps) => {
iat: today.getTime(), iat: today.getTime(),
iss: rest.iss || JWT_ISSUER, iss: rest.iss || JWT_ISSUER,
}, },
JWT_SECRET JWT_SECRET,
); );
}; };

12
src/utils/links.ts
View File

@@ -1,11 +1,5 @@
import { import { RESET_ROUTE, ROUTE_PREFIX, VERIFICATION_ROUTE } from '../constants/env';
RESET_ROUTE,
ROUTE_PREFIX,
VERIFICATION_ROUTE,
} from "../constants/env";
export const getPasswordResetPath = (token: string) => export const getPasswordResetPath = (token: string) => `${ROUTE_PREFIX}${RESET_ROUTE}?t=${token}`;
`${ROUTE_PREFIX}${RESET_ROUTE}?t=${token}`;
export const getVerificationPath = (token: string) => export const getVerificationPath = (token: string) => `${ROUTE_PREFIX}${VERIFICATION_ROUTE}?t=${token}`;
`${ROUTE_PREFIX}${VERIFICATION_ROUTE}?t=${token}`;

6
src/utils/parseTimeoutToMs.ts
View File

@@ -2,11 +2,11 @@ export const parseTimeoutToMs = (timeout: string) => {
const match = timeout.match(/(?<number>\d+)(?<unit>d|h|m)/gi)?.groups || {}; const match = timeout.match(/(?<number>\d+)(?<unit>d|h|m)/gi)?.groups || {};
const { number, unit } = match; const { number, unit } = match;
switch (unit) { switch (unit) {
case "d": case 'd':
return 1000 * 60 * 60 * 24 * parseInt(number); return 1000 * 60 * 60 * 24 * parseInt(number);
case "h": case 'h':
return 1000 * 60 * 60 * parseInt(number); return 1000 * 60 * 60 * parseInt(number);
case "m": case 'm':
default: default:
return 1000 * 60 * parseInt(number) || 1; return 1000 * 60 * parseInt(number) || 1;
} }

10
src/utils/password.ts
View File

@@ -1,12 +1,12 @@
import { pbkdf2Sync, randomBytes } from "crypto"; import { pbkdf2Sync, randomBytes } from 'crypto';
export const encrypt = (password: string) => { export const encrypt = (password: string) => {
const salt = randomBytes(16).toString("hex"); const salt = randomBytes(16).toString('hex');
const hash = pbkdf2Sync(password, salt, 10000, 512, "sha512").toString("hex"); const hash = pbkdf2Sync(password, salt, 10000, 512, 'sha512').toString('hex');
return `${salt}:${hash}`; return `${salt}:${hash}`;
}; };
export const verify = (test: string, secret: string) => { export const verify = (test: string, secret: string) => {
const [salt, hash] = secret.split(":"); const [salt, hash] = secret.split(':');
return pbkdf2Sync(test, salt, 10000, 512, "sha512").toString("hex") === hash; return pbkdf2Sync(test, salt, 10000, 512, 'sha512').toString('hex') === hash;
}; };

8
src/utils/tokens.ts
View File

@@ -1,7 +1,7 @@
import { sign } from "./jwt"; import { sign } from './jwt';
import { LOGIN_VALID_TIMEOUT } from "../constants/env"; import { LOGIN_VALID_TIMEOUT } from '../constants/env';
import { Status } from "../constants/auth"; import { Status } from '../constants/auth';
import { parseTimeoutToMs } from "./parseTimeoutToMs"; import { parseTimeoutToMs } from './parseTimeoutToMs';
export const generateLoginToken = (sub: string, status: Status) => export const generateLoginToken = (sub: string, status: Status) =>
sign({ sign({