@travetto/auth-model 7.0.0-rc.1 → 7.0.0-rc.3

package/README.md

@@ -100,29 +100,29 @@ import { User } from './model.ts';
 
 class AuthConfig {
   @InjectableFactory()
-  static getModelAuthService(svc: ModelCrudSupport) {
+  static getModelAuthService(service: ModelCrudSupport) {
     return new ModelAuthService(
-      svc,
+      service,
       User,
-      u => ({    // This converts User to a RegisteredPrincipal
+      user => ({    // This converts User to a RegisteredPrincipal
         source: 'model',
         provider: 'model',
-        id: u.id!,
-        permissions: u.permissions,
-        hash: u.hash,
-        salt: u.salt,
-        resetToken: u.resetToken,
-        resetExpires: u.resetExpires,
-        password: u.password,
-        details: u,
+        id: user.id!,
+        permissions: user.permissions,
+        hash: user.hash,
+        salt: user.salt,
+        resetToken: user.resetToken,
+        resetExpires: user.resetExpires,
+        password: user.password,
+        details: user,
       }),
-      u => User.from(({   // This converts a RegisteredPrincipal to a User
-        id: u.id,
-        permissions: [...(u.permissions || [])],
-        hash: u.hash,
-        salt: u.salt,
-        resetToken: u.resetToken,
-        resetExpires: u.resetExpires,
+      user => User.from(({   // This converts a RegisteredPrincipal to a User
+        id: user.id,
+        permissions: [...(user.permissions || [])],
+        hash: user.hash,
+        salt: user.salt,
+        resetToken: user.resetToken,
+        resetExpires: user.resetExpires,
       })
       )
     );
@@ -147,11 +147,11 @@ class UserService {
   async authenticate(identity: User) {
     try {
       return await this.auth.authenticate(identity);
-    } catch (err) {
-      if (err instanceof AppError && err.category === 'notfound') {
+    } catch (error) {
+      if (error instanceof AppError && error.category === 'notfound') {
         return await this.auth.register(identity);
       } else {
-        throw err;
+        throw error;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/auth-model",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Authentication model support for the Travetto framework",
   "keywords": [
     "authentication",
@@ -25,11 +25,11 @@
     "directory": "module/auth-model"
   },
   "dependencies": {
-    "@travetto/auth": "^7.0.0-rc.1",
-    "@travetto/model": "^7.0.0-rc.1"
+    "@travetto/auth": "^7.0.0-rc.3",
+    "@travetto/model": "^7.0.0-rc.3"
   },
   "peerDependencies": {
-    "@travetto/test": "^7.0.0-rc.1"
+    "@travetto/test": "^7.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/model.ts

@@ -1,4 +1,4 @@
-import { Util, Class, TimeUtil, Runtime, castTo } from '@travetto/runtime';
+import { Util, Class, TimeUtil, castTo } from '@travetto/runtime';
 import { ModelCrudSupport, ModelType, NotFoundError, OptionalId, ModelStorageUtil } from '@travetto/model';
 import { Principal, Authenticator, Authorizer, AuthenticationError } from '@travetto/auth';
 
@@ -31,8 +31,8 @@ export interface RegisteredPrincipal extends Principal {
   password?: string;
 }
 
-type ToPrincipal<T extends ModelType> = (t: OptionalId<T>) => RegisteredPrincipal;
-type FromPrincipal<T extends ModelType> = (t: Partial<RegisteredPrincipal>) => Partial<T>;
+type ToPrincipal<T extends ModelType> = (item: OptionalId<T>) => RegisteredPrincipal;
+type FromPrincipal<T extends ModelType> = (item: Partial<RegisteredPrincipal>) => Partial<T>;
 
 /**
  * A model-based auth service
@@ -74,10 +74,10 @@ export class ModelAuthService<T extends ModelType> implements Authenticator<T>,
 
   /**
    * Convert identity to a principal
-   * @param ident The registered identity to resolve
+   * @param identity The registered identity to resolve
    */
-  async #resolvePrincipal(ident: RegisteredPrincipal): Promise<RegisteredPrincipal> {
-    const user = await this.#retrieve(ident.id);
+  async #resolvePrincipal(identity: RegisteredPrincipal): Promise<RegisteredPrincipal> {
+    const user = await this.#retrieve(identity.id);
     return this.toPrincipal(user);
   }
 
@@ -87,19 +87,13 @@ export class ModelAuthService<T extends ModelType> implements Authenticator<T>,
    * @param password The password to authenticate against
    */
   async #authenticate(userId: string, password: string): Promise<RegisteredPrincipal> {
-    const ident = await this.#resolvePrincipal({ id: userId, details: {} });
+    const identity = await this.#resolvePrincipal({ id: userId, details: {} });
 
-    const hash = await AuthModelUtil.generateHash(password, ident.salt!);
-    if (hash !== ident.hash) {
+    const hash = await AuthModelUtil.generateHash(password, identity.salt!);
+    if (hash !== identity.hash) {
       throw new AuthenticationError('Invalid password');
     } else {
-      return ident;
-    }
-  }
-
-  async postConstruct(): Promise<void> {
-    if (ModelStorageUtil.isSupported(this.#modelService) && Runtime.dynamic) {
-      await this.#modelService.createModel?.(this.#cls);
+      return identity;
     }
   }
 
@@ -108,20 +102,20 @@ export class ModelAuthService<T extends ModelType> implements Authenticator<T>,
    * @param user The user to register
    */
   async register(user: OptionalId<T>): Promise<T> {
-    const ident = this.toPrincipal(user);
+    const identity = this.toPrincipal(user);
 
     try {
-      if (ident.id) {
-        await this.#retrieve(ident.id);
+      if (identity.id) {
+        await this.#retrieve(identity.id);
         throw new AuthenticationError('That id is already taken.', { category: 'data' });
       }
-    } catch (err) {
-      if (!(err instanceof NotFoundError)) {
-        throw err;
+    } catch (error) {
+      if (!(error instanceof NotFoundError)) {
+        throw error;
       }
     }
 
-    const fields = await AuthModelUtil.generatePassword(ident.password!);
+    const fields = await AuthModelUtil.generatePassword(identity.password!);
     const output: Partial<T> = { ...user, ...this.fromPrincipal(fields) };
     return await this.#modelService.create(this.#cls, this.#cls.from(castTo(output)));
   }
@@ -134,15 +128,15 @@ export class ModelAuthService<T extends ModelType> implements Authenticator<T>,
    */
   async changePassword(userId: string, password: string, oldPassword?: string): Promise<T> {
     const user = await this.#retrieve(userId);
-    const ident = this.toPrincipal(user);
+    const identity = this.toPrincipal(user);
 
-    if (oldPassword === ident.resetToken) {
-      if (ident.resetExpires && ident.resetExpires.getTime() < Date.now()) {
+    if (oldPassword === identity.resetToken) {
+      if (identity.resetExpires && identity.resetExpires.getTime() < Date.now()) {
         throw new AuthenticationError('Reset token has expired', { category: 'data' });
       }
     } else if (oldPassword !== undefined) {
-      const pw = await AuthModelUtil.generateHash(oldPassword, ident.salt!);
-      if (pw !== ident.hash) {
+      const oldPasswordHash = await AuthModelUtil.generateHash(oldPassword, identity.salt!);
+      if (oldPasswordHash !== identity.hash) {
         throw new AuthenticationError('Old password is required to change');
       }
     }
@@ -158,15 +152,15 @@ export class ModelAuthService<T extends ModelType> implements Authenticator<T>,
    */
   async generateResetToken(userId: string): Promise<RegisteredPrincipal> {
     const user = await this.#retrieve(userId);
-    const ident = this.toPrincipal(user);
+    const identity = this.toPrincipal(user);
     const salt = await Util.uuid();
 
-    ident.resetToken = await AuthModelUtil.generateHash(Util.uuid(), salt, 25000, 32);
-    ident.resetExpires = TimeUtil.fromNow(1, 'h');
+    identity.resetToken = await AuthModelUtil.generateHash(Util.uuid(), salt, 25000, 32);
+    identity.resetExpires = TimeUtil.fromNow(1, 'h');
 
-    const output: Partial<T> = { ...user, ...this.fromPrincipal(ident) };
+    const output: Partial<T> = { ...user, ...this.fromPrincipal(identity) };
     await this.#modelService.update(this.#cls, this.#cls.from(castTo(output)));
-    return ident;
+    return identity;
   }
 
   /**

package/src/util.ts

@@ -21,7 +21,7 @@ export class AuthModelUtil {
    */
   static generateHash(value: string, salt: string, iterations = 25000, keylen = 256, digest = 'sha256'): Promise<string> {
     const half = Math.trunc(Math.ceil(keylen / 2));
-    return pbkdf2(value, salt, iterations, half, digest).then(x => x.toString('hex').substring(0, keylen));
+    return pbkdf2(value, salt, iterations, half, digest).then(buffer => buffer.toString('hex').substring(0, keylen));
   }
 
   /**

package/support/test/model.ts

@@ -11,7 +11,7 @@ import { ModelAuthService, RegisteredPrincipal } from '../../src/model.ts';
 
 export const TestModelSvcSymbol = Symbol.for('@travetto/auth:test-model-svc');
 
-@Model({ autoCreate: false })
+@Model({ autoCreate: 'production' })
 class User implements RegisteredPrincipal {
   id: string;
   @Transient()