@tstdl/base 0.93.81 → 0.93.83

package/authentication/server/drizzle/{0000_violet_callisto.sql → 0000_majestic_proudstar.sql}

@@ -1,7 +1,8 @@
 CREATE TYPE "authentication"."subject_type" AS ENUM('system', 'user', 'service-account');--> statement-breakpoint
 CREATE TYPE "authentication"."user_status" AS ENUM('active', 'suspended', 'pending-approval', 'invited');--> statement-breakpoint
 CREATE TABLE "authentication"."credentials" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"id" uuid DEFAULT gen_random_uuid() NOT NULL,
+	"tenant_id" uuid NOT NULL,
 	"subject" uuid NOT NULL,
 	"hash_version" integer NOT NULL,
 	"salt" "bytea" NOT NULL,
@@ -11,11 +12,13 @@ CREATE TABLE "authentication"."credentials" (
 	"create_timestamp" timestamp with time zone NOT NULL,
 	"delete_timestamp" timestamp with time zone,
 	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
-	CONSTRAINT "credentials_subject_unique" UNIQUE("subject")
+	CONSTRAINT "credentials_tenant_id_id_pk" PRIMARY KEY("tenant_id","id"),
+	CONSTRAINT "credentials_tenant_id_subject_unique" UNIQUE("tenant_id","subject")
 );
 --> statement-breakpoint
 CREATE TABLE "authentication"."session" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"id" uuid DEFAULT gen_random_uuid() NOT NULL,
+	"tenant_id" uuid NOT NULL,
 	"subject" uuid NOT NULL,
 	"begin" timestamp with time zone NOT NULL,
 	"end" timestamp with time zone NOT NULL,
@@ -26,7 +29,8 @@ CREATE TABLE "authentication"."session" (
 	"revision_timestamp" timestamp with time zone NOT NULL,
 	"create_timestamp" timestamp with time zone NOT NULL,
 	"delete_timestamp" timestamp with time zone,
-	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL
+	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
+	CONSTRAINT "session_tenant_id_id_pk" PRIMARY KEY("tenant_id","id")
 );
 --> statement-breakpoint
 CREATE TABLE "authentication"."service_account" (
@@ -56,9 +60,10 @@ CREATE TABLE "authentication"."subject" (
 	"delete_timestamp" timestamp with time zone,
 	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
 	CONSTRAINT "subject_tenant_id_id_pk" PRIMARY KEY("tenant_id","id"),
-	CONSTRAINT "subject_system_account_id_unique" UNIQUE("system_account_id"),
-	CONSTRAINT "subject_user_id_unique" UNIQUE("user_id"),
-	CONSTRAINT "subject_service_account_id_unique" UNIQUE("service_account_id"),
+	CONSTRAINT "subject_tenant_id_service_account_id_unique" UNIQUE("tenant_id","service_account_id"),
+	CONSTRAINT "subject_tenant_id_user_id_unique" UNIQUE("tenant_id","user_id"),
+	CONSTRAINT "subject_tenant_id_system_account_id_unique" UNIQUE("tenant_id","system_account_id"),
+	CONSTRAINT "subject_id_unique" UNIQUE("id"),
 	CONSTRAINT "authentication_subject_reference_check" CHECK (num_nonnulls("authentication"."subject"."system_account_id", "authentication"."subject"."user_id", "authentication"."subject"."service_account_id") = 1)
 );
 --> statement-breakpoint
@@ -91,8 +96,8 @@ CREATE TABLE "authentication"."user" (
 	CONSTRAINT "user_tenant_id_email_unique" UNIQUE("tenant_id","email")
 );
 --> statement-breakpoint
-ALTER TABLE "authentication"."credentials" ADD CONSTRAINT "credentials_subject_subject_id_fk" FOREIGN KEY ("subject") REFERENCES "authentication"."subject"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "authentication"."session" ADD CONSTRAINT "session_subject_subject_id_fk" FOREIGN KEY ("subject") REFERENCES "authentication"."subject"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "authentication"."credentials" ADD CONSTRAINT "credentials_id_subject_fkey" FOREIGN KEY ("tenant_id","subject") REFERENCES "authentication"."subject"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "authentication"."session" ADD CONSTRAINT "session_id_subject_fkey" FOREIGN KEY ("tenant_id","subject") REFERENCES "authentication"."subject"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "authentication"."service_account" ADD CONSTRAINT "service_account_id_subject_fkey" FOREIGN KEY ("tenant_id","parent") REFERENCES "authentication"."subject"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "authentication"."subject" ADD CONSTRAINT "subject_id_system_account_fkey" FOREIGN KEY ("tenant_id","system_account_id") REFERENCES "authentication"."system_account"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "authentication"."subject" ADD CONSTRAINT "subject_id_user_fkey" FOREIGN KEY ("tenant_id","user_id") REFERENCES "authentication"."user"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint

package/authentication/server/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "c88f8c29-7029-4da0-b085-bd866a480533",
+  "id": "9385eff0-25d7-4ef6-be4b-8019af0a1424",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -11,10 +11,16 @@
         "id": {
           "name": "id",
           "type": "uuid",
-          "primaryKey": true,
+          "primaryKey": false,
           "notNull": true,
           "default": "gen_random_uuid()"
         },
+        "tenant_id": {
+          "name": "tenant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
         "subject": {
           "name": "subject",
           "type": "uuid",
@@ -73,27 +79,38 @@
       },
       "indexes": {},
       "foreignKeys": {
-        "credentials_subject_subject_id_fk": {
-          "name": "credentials_subject_subject_id_fk",
+        "credentials_id_subject_fkey": {
+          "name": "credentials_id_subject_fkey",
           "tableFrom": "credentials",
           "tableTo": "subject",
           "schemaTo": "authentication",
           "columnsFrom": [
+            "tenant_id",
             "subject"
           ],
           "columnsTo": [
+            "tenant_id",
             "id"
           ],
           "onDelete": "no action",
           "onUpdate": "no action"
         }
       },
-      "compositePrimaryKeys": {},
+      "compositePrimaryKeys": {
+        "credentials_tenant_id_id_pk": {
+          "name": "credentials_tenant_id_id_pk",
+          "columns": [
+            "tenant_id",
+            "id"
+          ]
+        }
+      },
       "uniqueConstraints": {
-        "credentials_subject_unique": {
-          "name": "credentials_subject_unique",
+        "credentials_tenant_id_subject_unique": {
+          "name": "credentials_tenant_id_subject_unique",
           "nullsNotDistinct": false,
           "columns": [
+            "tenant_id",
             "subject"
           ]
         }
@@ -109,10 +126,16 @@
         "id": {
           "name": "id",
           "type": "uuid",
-          "primaryKey": true,
+          "primaryKey": false,
           "notNull": true,
           "default": "gen_random_uuid()"
         },
+        "tenant_id": {
+          "name": "tenant_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
         "subject": {
           "name": "subject",
           "type": "uuid",
@@ -183,22 +206,32 @@
       },
       "indexes": {},
       "foreignKeys": {
-        "session_subject_subject_id_fk": {
-          "name": "session_subject_subject_id_fk",
+        "session_id_subject_fkey": {
+          "name": "session_id_subject_fkey",
           "tableFrom": "session",
           "tableTo": "subject",
           "schemaTo": "authentication",
           "columnsFrom": [
+            "tenant_id",
             "subject"
           ],
           "columnsTo": [
+            "tenant_id",
             "id"
           ],
           "onDelete": "no action",
           "onUpdate": "no action"
         }
       },
-      "compositePrimaryKeys": {},
+      "compositePrimaryKeys": {
+        "session_tenant_id_id_pk": {
+          "name": "session_tenant_id_id_pk",
+          "columns": [
+            "tenant_id",
+            "id"
+          ]
+        }
+      },
       "uniqueConstraints": {},
       "policies": {},
       "checkConstraints": {},
@@ -439,25 +472,35 @@
         }
       },
       "uniqueConstraints": {
-        "subject_system_account_id_unique": {
-          "name": "subject_system_account_id_unique",
+        "subject_tenant_id_service_account_id_unique": {
+          "name": "subject_tenant_id_service_account_id_unique",
           "nullsNotDistinct": false,
           "columns": [
-            "system_account_id"
+            "tenant_id",
+            "service_account_id"
           ]
         },
-        "subject_user_id_unique": {
-          "name": "subject_user_id_unique",
+        "subject_tenant_id_user_id_unique": {
+          "name": "subject_tenant_id_user_id_unique",
           "nullsNotDistinct": false,
           "columns": [
+            "tenant_id",
             "user_id"
           ]
         },
-        "subject_service_account_id_unique": {
-          "name": "subject_service_account_id_unique",
+        "subject_tenant_id_system_account_id_unique": {
+          "name": "subject_tenant_id_system_account_id_unique",
           "nullsNotDistinct": false,
           "columns": [
-            "service_account_id"
+            "tenant_id",
+            "system_account_id"
+          ]
+        },
+        "subject_id_unique": {
+          "name": "subject_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "id"
           ]
         }
       },

package/authentication/server/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1767826939668,
-      "tag": "0000_violet_callisto",
+      "when": 1767838186408,
+      "tag": "0000_majestic_proudstar",
       "breakpoints": true
     }
   ]

package/authentication/server/subject.service.d.ts

@@ -1,6 +1,22 @@
-import { Subject, SystemAccount } from '../models/index.js';
+import { ServiceAccount, Subject, User } from '../models/index.js';
+export type CreateUser = Pick<User, 'tenantId' | 'email' | 'firstName' | 'lastName'> & Partial<Pick<User, 'status'>>;
+export type CreateServiceAccount = Pick<ServiceAccount, 'tenantId' | 'description' | 'parent'>;
 export declare class SubjectService {
-    readonly subjectRepository: import("../../orm/server/index.js").EntityRepository<Subject>;
-    readonly systemAccountRepository: import("../../orm/server/index.js").EntityRepository<SystemAccount>;
+    #private;
+    getSubject(id: string): Promise<Subject>;
+    tryGetSubject(id: string): Promise<Subject | undefined>;
     getSystemAccountSubject(tenantId: string, identifier: string): Promise<Subject>;
+    createUser(data: CreateUser): Promise<User>;
+    updateUser(tenantId: string, userId: string, data: Partial<Pick<User, 'firstName' | 'lastName' | 'status'>>): Promise<void>;
+    updateUserEmail(tenantId: string, userId: string, email: string): Promise<void>;
+    getUserSubject(tenantId: string, userId: string): Promise<Subject>;
+    getUserByEmail(tenantId: string, email: string): Promise<User>;
+    tryGetUserByEmail(tenantId: string, email: string): Promise<User | undefined>;
+    hasUserByEmail(tenantId: string, email: string): Promise<boolean>;
+    getUserBySubject(subject: Subject): Promise<User>;
+    loadManyUsersByEmails(tenantId: string, emails: string[]): Promise<User[]>;
+    createServiceAccount(data: CreateServiceAccount): Promise<ServiceAccount>;
+    updateServiceAccount(tenantId: string, serviceAccountId: string, data: Partial<Pick<ServiceAccount, 'description'>> & Partial<Pick<Subject, 'displayName'>>): Promise<void>;
+    getServiceAccountSubject(tenantId: string, serviceAccountId: string): Promise<Subject>;
+    getServiceAccountBySubject(subject: Subject): Promise<ServiceAccount>;
 }

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/package.json

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