File Structure Change + Code Cleanup

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

@@ -1,21 +1,19 @@
 import * as oauth from 'oauth';
 
-export interface AccountsOauthTwitterOptions {
-  key: string;
-  secret: string;
-}
+import { Configuration } from './types/configuration';
+
 
 export class AccountsOAuthTwitter {
-  private options: AccountsOauthTwitterOptions;
+  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,3 @@
 import { AccountsOAuthTwitter } from './accounts-oauth-twitter';
 
-export { AccountsOauthTwitterOptions } from './accounts-oauth-twitter';
 export default AccountsOAuthTwitter;

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,25 +2,15 @@ import { UserObjectType } from '@accounts/common';
 import { AccountsServer, DBInterface, AuthService } from '@accounts/server';
 import * as requestPromise from 'request-promise';
 
-export interface OauthUser {
-  id: string;
-  email?: string;
-  profile?: object;
-}
-
-export interface OauthOptions {
-  [provider: string]: {
-    authenticate: (params: any) => Promise<OauthUser>;
-  };
-}
+import { OAuthOptions } from './types/oauth-options'
 
 export class AccountsOauth implements AuthService {
   public server: AccountsServer;
   public serviceName = 'oauth';
   private db: DBInterface;
-  private options: OauthOptions;
+  private options: OAuthOptions;
 
-  constructor(options) {
+  constructor(options: OAuthOptions) {
     this.options = options;
   }
 

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

@@ -0,0 +1,7 @@
+import { OAuthUser } from './oauth-user'
+
+export interface OAuthOptions {
+  [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__/encryption.ts → packages/password/__tests__/utils/encryption.ts

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

packages/password/src/accounts-password.ts

@@ -21,19 +21,16 @@ import {
   AccountsServer,
   generateRandomToken,
   AuthService,
+  getFirstUserEmail
 } from '@accounts/server';
-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);
-};
+import { hashPassword, bcryptPassword, verifyPassword } from './utils/encryption';
+
+
+import { PasswordCreateUserType } from './types/password-create-user-type'
+import { PasswordLoginType } from './types/password-login-type'
+import { PasswordType } from './types/password-type'
+
+import { isEmail } from './utils/isEmail'
 
 export interface AccountsPasswordOptions {
   passwordHashAlgorithm?: HashAlgorithm;

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,7 @@
+import { LoginUserIdentityType } from '@accounts/common';
+import { PasswordType } from './password-type'
+
+export interface PasswordLoginType {
+  user: string | LoginUserIdentityType;
+  password: PasswordType;
+}

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);

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 () => {

packages/server/src/accounts-server.ts

@@ -16,26 +16,19 @@ import {
   generateAccessToken,
   generateRefreshToken,
   generateRandomToken,
-} from './tokens';
-import { emailTemplates, EmailTemplateType, sendMail } from './email';
-import {
-  AccountsServerOptions,
-  ConnectionInformationsType,
-  AuthService,
-  DBInterface,
-} from './types';
-
-export interface TokenRecord {
-  token: string;
-  address: string;
-  when: number;
-  reason: string;
-}
+} from './utils/tokens';
 
-export interface JwtData {
-  token: string;
-  isImpersonated: boolean;
-}
+import { emailTemplates, sendMail } from './utils/email';
+import { ServerHooks } from './utils/server-hooks';
+
+import { AccountsServerOptions } from './types/accounts-server-options'
+import { ConnectionInformationsType } from './types/connection-informations-type'
+import { AuthService } from './types/auth-service'
+import { DBInterface } from './types/db-interface'
+import { TokenRecord } from './types/token-record'
+import { JwtData } from './types/jwt-data'
+import { RemoveListenerHandle } from './types/remove-listener-handle'
+import { EmailTemplateType } from './types/email-template-type'
 
 const defaultOptions = {
   tokenSecret: 'secret',
@@ -53,23 +46,6 @@ const defaultOptions = {
   siteUrl: 'http://localhost:3000',
 };
 
-export type RemoveListnerHandle = () => EventEmitter;
-
-export const ServerHooks = {
-  LoginSuccess: 'LoginSuccess',
-  LoginError: 'LoginError',
-  LogoutSuccess: 'LogoutSuccess',
-  LogoutError: 'LogoutError',
-  CreateUserSuccess: 'CreateUserSuccess',
-  CreateUserError: 'CreateUserError',
-  ResumeSessionSuccess: 'ResumeSessionSuccess',
-  ResumeSessionError: 'ResumeSessionError',
-  RefreshTokensSuccess: 'RefreshTokensSuccess',
-  RefreshTokensError: 'RefreshTokensError',
-  ImpersonationSuccess: 'ImpersonationSuccess',
-  ImpersonationError: 'ImpersonationError',
-};
-
 export class AccountsServer {
   public options: AccountsServerOptions;
   private services: { [key: string]: AuthService };
@@ -105,51 +81,51 @@ export class AccountsServer {
     return this.options;
   }
 
-  public onLoginSuccess(callback: HookListener): RemoveListnerHandle {
+  public onLoginSuccess(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.LoginSuccess, callback);
   }
 
-  public onLoginError(callback: HookListener): RemoveListnerHandle {
+  public onLoginError(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.LoginError, callback);
   }
 
-  public onLogoutSuccess(callback: HookListener): RemoveListnerHandle {
+  public onLogoutSuccess(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.LogoutSuccess, callback);
   }
 
-  public onLogoutError(callback: HookListener): RemoveListnerHandle {
+  public onLogoutError(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.LogoutError, callback);
   }
 
-  public onCreateUserSuccess(callback: HookListener): RemoveListnerHandle {
+  public onCreateUserSuccess(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.CreateUserSuccess, callback);
   }
 
-  public onCreateUserError(callback: HookListener): RemoveListnerHandle {
+  public onCreateUserError(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.CreateUserError, callback);
   }
 
-  public onResumeSessionSuccess(callback: HookListener): RemoveListnerHandle {
+  public onResumeSessionSuccess(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.ResumeSessionSuccess, callback);
   }
 
-  public onResumeSessionError(callback: HookListener): RemoveListnerHandle {
+  public onResumeSessionError(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.ResumeSessionError, callback);
   }
 
-  public onRefreshTokensSuccess(callback: HookListener): RemoveListnerHandle {
+  public onRefreshTokensSuccess(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.RefreshTokensSuccess, callback);
   }
 
-  public onRefreshTokensError(callback: HookListener): RemoveListnerHandle {
+  public onRefreshTokensError(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.RefreshTokensError, callback);
   }
 
-  public onImpersonationSuccess(callback: HookListener): RemoveListnerHandle {
+  public onImpersonationSuccess(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.ImpersonationSuccess, callback);
   }
 
-  public onImpersonationError(callback: HookListener): RemoveListnerHandle {
+  public onImpersonationError(callback: HookListener): RemoveListenerHandle {
     return this.on(ServerHooks.ImpersonationError, callback);
   }
 
@@ -542,7 +518,7 @@ export class AccountsServer {
     return this.db.setProfile(userId, { ...user.profile, ...profile });
   }
 
-  public on(eventName: string, callback: HookListener): RemoveListnerHandle {
+  public on(eventName: string, callback: HookListener): RemoveListenerHandle {
     this.hooks.on(eventName, callback);
 
     return () => this.hooks.removeListener(eventName, callback);

packages/server/src/index.ts

@@ -1,7 +1,11 @@
 import { AccountsServer } from './accounts-server';
-import * as encryption from './encryption';
-import { generateRandomToken } from './tokens';
-import { AuthService, DBInterface, ConnectionInformationsType } from './types';
+import * as encryption from './utils/encryption';
+import { generateRandomToken } from './utils/tokens';
+import { getFirstUserEmail } from './utils/get-first-user-email';
+
+import { ConnectionInformationsType } from './types/connection-informations-type'
+import { AuthService } from './types/auth-service'
+import { DBInterface } from './types/db-interface'
 
 export default AccountsServer;
 export {
@@ -11,4 +15,5 @@ export {
   DBInterface,
   generateRandomToken,
   ConnectionInformationsType,
+  getFirstUserEmail
 };