@tstdl/base 0.93.80 → 0.93.82

package/authentication/server/subject.service.js

@@ -4,25 +4,36 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { BadRequestError } from '../../errors/bad-request.error.js';
+import { formatPersonName } from '../../formats/formats.js';
 import { Singleton } from '../../injector/index.js';
 import { injectRepository } from '../../orm/server/index.js';
-import { isUndefined } from '../../utils/type-guards.js';
-import { Subject, SubjectType, SystemAccount } from '../models/index.js';
+import { mailPattern } from '../../utils/patterns.js';
+import { assertNotNull, isDefined, isUndefined } from '../../utils/type-guards.js';
+import { ServiceAccount, Subject, SubjectType, SystemAccount, User, UserStatus } from '../models/index.js';
 let SubjectService = class SubjectService {
-    subjectRepository = injectRepository(Subject);
-    systemAccountRepository = injectRepository(SystemAccount);
+    #subjectRepository = injectRepository(Subject);
+    #systemAccountRepository = injectRepository(SystemAccount);
+    #userRepository = injectRepository(User);
+    #serviceAccountRepository = injectRepository(ServiceAccount);
+    async getSubject(id) {
+        return await this.#subjectRepository.load(id);
+    }
+    async tryGetSubject(id) {
+        return await this.#subjectRepository.tryLoad(id);
+    }
     async getSystemAccountSubject(tenantId, identifier) {
-        return await this.subjectRepository.transaction(async (tx) => {
-            let systemAccount = await this.systemAccountRepository.withTransaction(tx).tryLoadByQuery({
+        return await this.#subjectRepository.transaction(async (tx) => {
+            let systemAccount = await this.#systemAccountRepository.withTransaction(tx).tryLoadByQuery({
                 tenantId,
                 identifier,
             });
             if (isUndefined(systemAccount)) {
-                systemAccount = await this.systemAccountRepository.withTransaction(tx).insert({
+                systemAccount = await this.#systemAccountRepository.withTransaction(tx).insert({
                     tenantId,
                     identifier,
                 });
-                return await this.subjectRepository.withTransaction(tx).insert({
+                return await this.#subjectRepository.withTransaction(tx).insert({
                     type: SubjectType.System,
                     tenantId,
                     systemAccountId: systemAccount.id,
@@ -31,12 +42,118 @@ let SubjectService = class SubjectService {
                     serviceAccountId: null,
                 });
             }
-            return await this.subjectRepository.withTransaction(tx).loadByQuery({
+            return await this.#subjectRepository.withTransaction(tx).loadByQuery({
                 tenantId,
                 systemAccountId: systemAccount.id,
             });
         });
     }
+    async createUser(data) {
+        const { tenantId, email, firstName, lastName, status } = data;
+        return await this.#userRepository.transaction(async (tx) => {
+            const user = await this.#userRepository.withTransaction(tx).insert({
+                tenantId,
+                email,
+                firstName,
+                lastName,
+                status: status ?? UserStatus.Active,
+            });
+            await this.#subjectRepository.withTransaction(tx).insert({
+                tenantId,
+                type: SubjectType.User,
+                displayName: `${firstName} ${lastName}`,
+                systemAccountId: null,
+                userId: user.id,
+                serviceAccountId: null,
+            });
+            return user;
+        });
+    }
+    async updateUser(tenantId, userId, data) {
+        const { firstName, lastName, status } = data;
+        await this.#userRepository.transaction(async (tx) => {
+            const updateData = {};
+            if (isDefined(firstName)) {
+                updateData.firstName = firstName;
+            }
+            if (isDefined(lastName)) {
+                updateData.lastName = lastName;
+            }
+            if (isDefined(status)) {
+                updateData.status = status;
+            }
+            if (Object.keys(updateData).length > 0) {
+                const updatedUser = await this.#userRepository.withTransaction(tx).updateByQuery({ tenantId, userId }, updateData);
+                if (isDefined(firstName) || isDefined(lastName)) {
+                    await this.#subjectRepository.withTransaction(tx).updateByQuery({ tenantId, userId }, { displayName: formatPersonName(updatedUser) });
+                }
+            }
+        });
+    }
+    async updateUserEmail(tenantId, userId, email) {
+        // TODO: future (out of scope right now): validate mail flow
+        if (!mailPattern.test(email)) {
+            throw new BadRequestError(`Invalid email format.`);
+        }
+        await this.#userRepository.updateByQuery({ tenantId, userId }, { email });
+    }
+    async getUserSubject(tenantId, userId) {
+        return await this.#subjectRepository.loadByQuery({ tenantId, userId });
+    }
+    async getUserByEmail(tenantId, email) {
+        return await this.#userRepository.loadByQuery({ tenantId, email });
+    }
+    async tryGetUserByEmail(tenantId, email) {
+        return await this.#userRepository.tryLoadByQuery({ tenantId, email });
+    }
+    async hasUserByEmail(tenantId, email) {
+        const user = await this.tryGetUserByEmail(tenantId, email);
+        return isDefined(user);
+    }
+    async getUserBySubject(subject) {
+        assertNotNull(subject.userId, 'Subject is not a user subject');
+        return await this.#userRepository.load(subject.userId);
+    }
+    async loadManyUsersByEmails(tenantId, emails) {
+        return await this.#userRepository.loadManyByQuery({ tenantId, email: { $in: emails } });
+    }
+    async createServiceAccount(data) {
+        const { tenantId, description, parent } = data;
+        return await this.#serviceAccountRepository.transaction(async (tx) => {
+            const serviceAccount = await this.#serviceAccountRepository.withTransaction(tx).insert({
+                tenantId,
+                description,
+                parent,
+            });
+            await this.#subjectRepository.withTransaction(tx).insert({
+                tenantId,
+                type: SubjectType.ServiceAccount,
+                displayName: description,
+                userId: null,
+                systemAccountId: null,
+                serviceAccountId: serviceAccount.id,
+            });
+            return serviceAccount;
+        });
+    }
+    async updateServiceAccount(tenantId, serviceAccountId, data) {
+        const { displayName, description } = data;
+        await this.#subjectRepository.transaction(async (tx) => {
+            if (isDefined(displayName)) {
+                await this.#subjectRepository.withTransaction(tx).updateByQuery({ tenantId, serviceAccountId }, { displayName });
+            }
+            if (isDefined(description)) {
+                await this.#serviceAccountRepository.withTransaction(tx).updateByQuery({ tenantId, serviceAccountId }, { description });
+            }
+        });
+    }
+    async getServiceAccountSubject(tenantId, serviceAccountId) {
+        return await this.#subjectRepository.loadByQuery({ tenantId, serviceAccountId });
+    }
+    async getServiceAccountBySubject(subject) {
+        assertNotNull(subject.serviceAccountId, 'Subject is not a service account subject');
+        return await this.#serviceAccountRepository.load(subject.serviceAccountId);
+    }
 };
 SubjectService = __decorate([
     Singleton()

package/authentication/types.d.ts

@@ -0,0 +1,6 @@
+export type SubjectInput = {
+    /** The tenant id if available. */
+    tenantId?: string;
+    /** The subject provided by the user (like an email address). */
+    subject: string;
+};

package/authentication/types.js

@@ -0,0 +1 @@
+export {};

package/examples/api/authentication.js

@@ -17,7 +17,8 @@ import { timeout } from '../../utils/timing.js';
 import { Agent } from 'undici';
 async function serverTest() {
     const authenticationService = await injectAsync(AuthenticationServerService);
-    await authenticationService.setCredentials('foobar', 'mysuperdupersecret-fvhc54w');
+    const subject = await authenticationService.resolveSubject({ subject: 'foobar' });
+    await authenticationService.setCredentials(subject, 'mysuperdupersecret-fvhc54w');
 }
 async function clientTest() {
     const authenticationService = inject(AuthenticationClientService);
@@ -25,7 +26,7 @@ async function clientTest() {
     await timeout(250); // allow server to initialize
     const passwordCheckResult = await authenticationService.checkSecret('123456');
     console.log({ 'password check for "123456"': passwordCheckResult });
-    await authenticationService.login('foobar', 'mysuperdupersecret-fvhc54w');
+    await authenticationService.login({ subject: 'foobar' }, 'mysuperdupersecret-fvhc54w');
     authenticationService.token$.subscribe((token) => console.log({ token }));
 }
 async function test() {

package/examples/api/custom-authentication.js

@@ -18,7 +18,7 @@ import { AuthenticationAncillaryService, AuthenticationApiController, Authentica
 import { configureUndiciHttpClientAdapter } from '../../http/client/adapters/undici.adapter.js';
 import { configureHttpClient } from '../../http/client/module.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
-import { Singleton } from '../../injector/decorators.js';
+import { Singleton } from '../../injector/index.js';
 import { inject, injectAsync } from '../../injector/inject.js';
 import { configureLocalMessageBus } from '../../message-bus/local/module.js';
 import { WebServerModule } from '../../module/modules/index.js';
@@ -65,17 +65,18 @@ __decorate([
 ], AuthenticationData.prototype, "deviceId", void 0);
 const CustomAuthenticationApiClient = getAuthenticationApiClient(CustomTokenPaylod, AuthenticationData, emptyObjectSchema);
 let CustomAuthenticationAncillaryService = class CustomAuthenticationAncillaryService extends AuthenticationAncillaryService {
-    getTokenPayload(_subject, authenticationData) {
+    getTokenPayload(_subject, authenticationData, _context) {
         return { deviceRegistrationId: `registration:${authenticationData.deviceId}` };
     }
-    resolveSubject() {
-        throw new Error('Method not implemented.');
+    async resolveSubjects(data) {
+        const subjects = await this.subjectRepository.loadManyByQuery({ id: data.subject });
+        return subjects;
     }
-    handleInitSecretReset() {
+    canImpersonate(_token, _subject, _authenticationData) {
         throw new Error('Method not implemented.');
     }
-    canImpersonate() {
-        throw new Error('Method not implemented.');
+    handleInitSecretReset() {
+        // send mail
     }
 };
 CustomAuthenticationAncillaryService = __decorate([
@@ -83,13 +84,14 @@ CustomAuthenticationAncillaryService = __decorate([
 ], CustomAuthenticationAncillaryService);
 async function serverTest() {
     const authenticationService = await injectAsync(AuthenticationServerService);
-    await authenticationService.setCredentials('foobar', 'supersecret-dupidupudoo9275');
+    const subject = await authenticationService.resolveSubject({ subject: 'foobar' });
+    await authenticationService.setCredentials(subject, 'supersecret-dupidupudoo9275');
 }
 async function clientTest(application) {
     const authenticationService = inject(AuthenticationClientService);
     await timeout(1500); // allow server to initialize
     authenticationService.initialize();
-    await authenticationService.login('foobar', 'supersecret-dupidupudoo9275');
+    await authenticationService.login({ subject: 'foobar' }, 'supersecret-dupidupudoo9275');
     authenticationService.token$.subscribe((token) => console.log({ token }));
     application.requestShutdown();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.80",
+  "version": "0.93.82",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"