Cleanup/structure: apply structure pattern to the suite

packages/oauth-twitter/src/accounts-oauth-twitter.ts

@@ -1,21 +1,18 @@
 import * as oauth from 'oauth';
 
-export interface AccountsOauthTwitterOptions {
-  key: string;
-  secret: string;
-}
+import { Configuration } from './types/configuration'
 
-export class AccountsOAuthTwitter {
-  private options: AccountsOauthTwitterOptions;
+export default class AccountsOAuthTwitter {
+  private config: Configuration;
   private oauth: any;
 
-  constructor(options: AccountsOauthTwitterOptions) {
-    this.options = options;
+  constructor(config: Configuration) {
+    this.config = config;
     this.oauth = new oauth.OAuth(
       'https://twitter.com/oauth/request_token',
       'https://twitter.com/oauth/access_token',
-      this.options.key,
-      this.options.secret,
+      this.config.key,
+      this.config.secret,
       '1.0A',
       null,
       'HMAC-SHA1'

packages/oauth-twitter/src/index.ts

@@ -1,4 +1,2 @@
-import { AccountsOAuthTwitter } from './accounts-oauth-twitter';
-
-export { AccountsOauthTwitterOptions } from './accounts-oauth-twitter';
-export default AccountsOAuthTwitter;
+export { default } from './accounts-oauth-twitter';
+export { Configuration } from './types/configuration';

packages/oauth-twitter/src/types/configuration.ts

@@ -0,0 +1,4 @@
+export interface Configuration {
+  key: string;
+  secret: string;
+}

packages/oauth/src/accounts-oauth.ts

@@ -2,6 +2,8 @@ import { UserObjectType } from '@accounts/common';
 import { AccountsServer, DBInterface, AuthService } from '@accounts/server';
 import * as requestPromise from 'request-promise';
 
+import { Configuration } from './types/configuration';
+
 export interface OauthUser {
   id: string;
   email?: string;
@@ -18,9 +20,9 @@ export class AccountsOauth implements AuthService {
   public server: AccountsServer;
   public serviceName = 'oauth';
   private db: DBInterface;
-  private options: OauthOptions;
+  private options: Configuration;
 
-  constructor(options) {
+  constructor(options: Configuration) {
     this.options = options;
   }
 

packages/oauth/src/types/configuration.ts

@@ -0,0 +1,7 @@
+import { OAuthUser } from './oauth-user';
+
+export interface Configuration {
+  [provider: string]: {
+    authenticate: (params: any) => Promise<OAuthUser>;
+  };
+}

packages/oauth/src/types/oauth-user.ts

@@ -0,0 +1,5 @@
+export interface OAuthUser {
+  id: string;
+  email?: string;
+  profile?: object;
+}

packages/password/__tests__/accounts-password.ts

@@ -1,10 +1,10 @@
 import { set } from 'lodash';
-import { AccountsPassword } from '../src';
+import AccountsPassword from '../src';
 
 describe('AccountsPassword', () => {
   const password = new AccountsPassword({});
 
-  describe('config', () => {
+  describe('options', () => {
     it('should have default options', async () => {
       expect(password.options.passwordResetTokenExpirationInDays).toBe(3);
     });

packages/password/__tests__/encryption.ts → packages/password/__tests__/utils/encryption.ts

@@ -2,7 +2,7 @@ import {
   bcryptPassword,
   hashPassword,
   verifyPassword,
-} from '../src/encryption';
+} from '../../src/utils/encryption';
 
 describe('encryption', () => {
   describe('bcryptPassword', () => {

packages/password/src/accounts-password.ts

@@ -21,32 +21,18 @@ import {
   AccountsServer,
   generateRandomToken,
   AuthService,
+  getFirstUserEmail
 } from '@accounts/server';
-import { TwoFactor, AccountsTwoFactorOptions } from '@accounts/two-factor';
-import { getFirstUserEmail } from '@accounts/server/lib/utils';
-import { hashPassword, bcryptPassword, verifyPassword } from './encryption';
-import {
-  PasswordCreateUserType,
-  PasswordLoginType,
-  PasswordType,
-} from './types';
-
-export const isEmail = (email?: string) => {
-  const re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
-  return email && re.test(email);
-};
 
-export interface AccountsPasswordOptions {
-  twoFactor?: AccountsTwoFactorOptions;
-  passwordHashAlgorithm?: HashAlgorithm;
-  passwordResetTokenExpirationInDays?: number;
-  passwordEnrollTokenExpirationInDays?: number;
-  minimumPasswordLength?: number;
-  validateNewUser?: (user: CreateUserType) => Promise<boolean>;
-  validateEmail?(email?: string): boolean;
-  validatePassword?(password?: PasswordType): boolean;
-  validateUsername?(username?: string): boolean;
-}
+import TwoFactor, { TwoFactorConfiguration } from '@accounts/two-factor';
+
+import { Configuration } from './types/configuration';
+import { PasswordCreateUserType } from './types/password-create-user-type';
+import { PasswordLoginType } from './types/password-login-type';
+import { PasswordType } from './types/password-type';
+
+import { hashPassword, bcryptPassword, verifyPassword } from './utils/encryption';
+import { isEmail } from './utils/isEmail';
 
 const defaultOptions = {
   passwordResetTokenExpirationInDays: 3,
@@ -72,10 +58,10 @@ export default class AccountsPassword implements AuthService {
   public serviceName = 'password';
   public server: AccountsServer;
   public twoFactor: TwoFactor;
-  private options: AccountsPasswordOptions;
+  private options: Configuration;
   private db: DBInterface;
 
-  constructor(options: AccountsPasswordOptions = {}) {
+  constructor(options: Configuration = {}) {
     this.options = { ...defaultOptions, ...options };
     this.twoFactor = new TwoFactor(options.twoFactor);
   }

packages/password/src/types/configuration.ts

@@ -0,0 +1,16 @@
+import { CreateUserType, HashAlgorithm } from '@accounts/common';
+import { TwoFactorConfiguration } from '@accounts/two-factor';
+
+import { PasswordType } from './password-type';
+
+export interface Configuration {
+  twoFactor?: TwoFactorConfiguration;
+  passwordHashAlgorithm?: HashAlgorithm;
+  passwordResetTokenExpirationInDays?: number;
+  passwordEnrollTokenExpirationInDays?: number;
+  minimumPasswordLength?: number;
+  validateNewUser?: (user: CreateUserType) => Promise<boolean>;
+  validateEmail?(email?: string): boolean;
+  validatePassword?(password?: PasswordType): boolean;
+  validateUsername?(username?: string): boolean;
+}

packages/password/src/types/password-create-user-type.ts

@@ -0,0 +1,6 @@
+import { CreateUserType } from '@accounts/common';
+import { PasswordType } from './password-type';
+
+export interface PasswordCreateUserType extends CreateUserType {
+  password: PasswordType;
+}

packages/password/src/types/password-login-type.ts

@@ -0,0 +1,10 @@
+import { LoginUserIdentityType } from '@accounts/common';
+import { PasswordType } from './password-type';
+
+export interface PasswordLoginType {
+  user: string | LoginUserIdentityType;
+  // User password
+  password: PasswordType;
+  // Two factor code
+  code?: string;
+}

packages/password/src/types/password-type.ts

@@ -0,0 +1,8 @@
+import { HashAlgorithm } from '@accounts/common';
+
+export type PasswordType =
+  | string
+  | {
+      digest: string;
+      algorithm: HashAlgorithm;
+    };

packages/password/src/encryption.ts → packages/password/src/utils/encryption.ts

@@ -1,6 +1,6 @@
 import * as bcrypt from 'bcryptjs';
 import * as crypto from 'crypto';
-import { PasswordType } from './types';
+import { PasswordType } from '../types/password-type';
 
 export const bcryptPassword = async (password: string): Promise<string> => {
   const salt = await bcrypt.genSalt(10);
@@ -18,7 +18,6 @@ export const hashPassword = (password: PasswordType, algorithm: string) => {
   return password.digest;
 };
 
-export const verifyPassword = async (
-  password: string,
+export const verifyPassword = async ( password: string,
   hash: string
 ): Promise<boolean> => bcrypt.compare(password, hash);

packages/password/src/utils/isEmail.ts

@@ -0,0 +1,4 @@
+export const isEmail = (email?: string) => {
+  const re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return email && re.test(email);
+};

packages/server/__tests__/accounts-server.ts → packages/server/__tests__/account-server.ts

@@ -1,10 +1,11 @@
 import * as jwtDecode from 'jwt-decode';
-import { AccountsServer, JwtData } from '../src/accounts-server';
+import { AccountsServer } from '../src/accounts-server';
+import { JwtData } from '../src/types/jwt-data';
 import {
   bcryptPassword,
   hashPassword,
   verifyPassword,
-} from '../src/encryption';
+} from '../src/utils/encryption';
 
 describe('AccountsServer', () => {
   const db = {

packages/server/__tests__/email.ts → packages/server/__tests__/utils/email.ts

@@ -1,4 +1,4 @@
-import { emailTemplates } from '../src/email';
+import { emailTemplates } from '../../src/utils/email';
 
 describe('email', () => {
   describe('emailTemplates', () => {

packages/server/__tests__/encryption.ts → packages/server/__tests__/utils/encryption.ts

@@ -2,7 +2,7 @@ import {
   bcryptPassword,
   hashPassword,
   verifyPassword,
-} from '../src/encryption';
+} from '../../src/utils/encryption';
 
 describe('bcryptPassword', () => {
   it('hashes password using bcrypt', async () => {