create-forgeon 0.3.19 → 0.3.21

package/templates/module-presets/accounts/packages/accounts-api/src/auth-core.service.ts

@@ -12,12 +12,9 @@ import type {
   UserRecordDto,
 } from '@forgeon/accounts-contracts';
 import { ACCOUNTS_EMAIL_PORT, type AccountsEmailPort } from './accounts-email.port';
-import {
-  ACCOUNTS_PERSISTENCE_PORT,
-  type AccountsPersistencePort,
-} from './accounts-persistence.port';
 import { AuthJwtService } from './auth-jwt.service';
 import { AuthPasswordService } from './auth-password.service';
+import { AuthStore } from './auth.store';
 import type { AuthRefreshTokenPayload } from './auth.types';
 import { UsersService } from './users.service';
 import { toUserRecordDto } from './users.types';
@@ -33,8 +30,7 @@ const AUTH_ERROR_CODES = {
 @Injectable()
 export class AuthCoreService {
   constructor(
-    @Inject(ACCOUNTS_PERSISTENCE_PORT)
-    private readonly persistence: AccountsPersistencePort,
+    private readonly authStore: AuthStore,
     @Inject(ACCOUNTS_EMAIL_PORT)
     private readonly emailPort: AccountsEmailPort,
     private readonly authJwtService: AuthJwtService,
@@ -44,7 +40,7 @@ export class AuthCoreService {
 
   async registerWithPassword(input: RegisterRequest): Promise<AuthSessionResponse> {
     const email = input.email.trim().toLowerCase();
-    const existing = await this.persistence.findPasswordAccountByEmail(email);
+    const existing = await this.authStore.findPasswordAccountByEmail(email);
     if (existing) {
       throw new ConflictException({
         message: 'Email is already registered',
@@ -53,7 +49,7 @@ export class AuthCoreService {
     }
 
     const passwordHash = await this.authPasswordService.hash(input.password);
-    const account = await this.persistence.createPasswordAccount({
+    const account = await this.authStore.createPasswordAccount({
       email,
       passwordHash,
       status: 'active',
@@ -88,7 +84,7 @@ export class AuthCoreService {
 
   async loginWithPassword(emailInput: string, password: string): Promise<AuthSessionResponse> {
     const email = emailInput.trim().toLowerCase();
-    const account = await this.persistence.findPasswordAccountByEmail(email);
+    const account = await this.authStore.findPasswordAccountByEmail(email);
     if (!account?.passwordHash) {
       throw this.invalidCredentialsError();
     }
@@ -119,7 +115,7 @@ export class AuthCoreService {
       });
     }
 
-    const record = await this.persistence.findRefreshTokenById(payload.jti);
+    const record = await this.authStore.findRefreshTokenById(payload.jti);
     if (!record || record.revokedAt || record.userId !== payload.sub || record.expiresAt <= new Date()) {
       throw new UnauthorizedException({
         message: 'Refresh token is invalid or expired',
@@ -129,14 +125,14 @@ export class AuthCoreService {
 
     const matched = await this.authPasswordService.verify(refreshToken, record.tokenHash);
     if (!matched) {
-      await this.persistence.revokeRefreshToken(record.id, new Date());
+      await this.authStore.revokeRefreshToken(record.id, new Date());
       throw new UnauthorizedException({
         message: 'Refresh token is invalid or expired',
         details: { code: AUTH_ERROR_CODES.refreshInvalid },
       });
     }
 
-    const account = await this.persistence.findAccountByUserId(payload.sub);
+    const account = await this.authStore.findAccountByUserId(payload.sub);
     if (!account) {
       throw new UnauthorizedException({
         message: 'Refresh token is invalid or expired',
@@ -145,7 +141,7 @@ export class AuthCoreService {
     }
 
     this.assertAccountActive(account);
-    await this.persistence.revokeRefreshToken(record.id, new Date());
+    await this.authStore.revokeRefreshToken(record.id, new Date());
     return this.issueSession(toUserRecordDto(account));
   }
 
@@ -158,18 +154,18 @@ export class AuthCoreService {
       });
     }
 
-    await this.persistence.revokeRefreshToken(payload.jti, new Date());
+    await this.authStore.revokeRefreshToken(payload.jti, new Date());
   }
 
   async changePassword(userId: string, newPassword: string): Promise<void> {
     const passwordHash = await this.authPasswordService.hash(newPassword);
-    await this.persistence.updatePassword(userId, passwordHash);
-    await this.persistence.revokeRefreshTokensForUser(userId, new Date());
+    await this.authStore.updatePassword(userId, passwordHash);
+    await this.authStore.revokeRefreshTokensForUser(userId, new Date());
   }
 
   async requestPasswordReset(emailInput: string) {
     const email = emailInput.trim().toLowerCase();
-    const account = await this.persistence.findPasswordAccountByEmail(email);
+    const account = await this.authStore.findPasswordAccountByEmail(email);
     if (account) {
       await this.emailPort.sendPasswordResetEmail({
         email,
@@ -218,7 +214,7 @@ export class AuthCoreService {
     return {
       status: 'ok',
       feature: 'accounts',
-      storage: 'db-adapter',
+      storage: 'db-prisma',
       emailDelivery: 'stub',
       selfServiceRoutes: [
         '/api/users/:id',
@@ -245,7 +241,7 @@ export class AuthCoreService {
     ]);
 
     const tokenHash = await this.authPasswordService.hash(refreshToken);
-    await this.persistence.createRefreshToken({
+    await this.authStore.createRefreshToken({
       id: refreshId,
       userId: user.id,
       tokenHash,

package/templates/module-presets/accounts/{apps/api/src/accounts/prisma-accounts-persistence.store.ts → packages/accounts-api/src/auth.store.ts}

@@ -1,15 +1,43 @@
-import { Prisma } from '@prisma/client';
-import {
-  type AccountsPersistencePort,
-  type CreatePasswordAccountInput,
-  type PasswordAccountRecord,
-  type RefreshTokenRecord,
-} from '@forgeon/accounts-api';
-import { PrismaService } from '@forgeon/db-prisma';
 import { Injectable, NotFoundException } from '@nestjs/common';
+import type { IdentityProvider, JsonObject } from '@forgeon/accounts-contracts';
+import { PrismaService } from '@forgeon/db-prisma';
+import type { UserRecord } from './users.types';
+import { mapUserRecord, toPrismaJsonInput } from './users.types';
+
+export type PasswordAccountRecord = UserRecord & {
+  provider: IdentityProvider;
+  providerId: string;
+  passwordHash: string | null;
+};
+
+export type RefreshTokenRecord = {
+  id: string;
+  userId: string;
+  tokenHash: string;
+  expiresAt: Date;
+  revokedAt: Date | null;
+  createdAt: Date;
+};
+
+export interface CreatePasswordAccountInput {
+  email: string;
+  passwordHash: string;
+  status: string;
+  userData: JsonObject | null;
+  profile: {
+    name: string | null;
+    avatar: string | null;
+    data: JsonObject | null;
+  };
+  settings: {
+    theme: string | null;
+    locale: string | null;
+    data: JsonObject | null;
+  };
+}
 
 @Injectable()
-export class PrismaAccountsPersistenceStore implements AccountsPersistencePort {
+export class AuthStore {
   constructor(private readonly prisma: PrismaService) {}
 
   async createPasswordAccount(input: CreatePasswordAccountInput): Promise<PasswordAccountRecord> {
@@ -17,19 +45,19 @@ export class PrismaAccountsPersistenceStore implements AccountsPersistencePort {
       const user = await tx.user.create({
         data: {
           status: input.status,
-          data: this.toNullableJson(input.userData),
+          data: toPrismaJsonInput(input.userData),
           profile: {
             create: {
               name: input.profile.name,
               avatar: input.profile.avatar,
-              data: this.toNullableJson(input.profile.data),
+              data: toPrismaJsonInput(input.profile.data),
             },
           },
           settings: {
             create: {
               theme: input.settings.theme,
               locale: input.settings.locale,
-              data: this.toNullableJson(input.settings.data),
+              data: toPrismaJsonInput(input.settings.data),
             },
           },
         },
@@ -159,174 +187,24 @@ export class PrismaAccountsPersistenceStore implements AccountsPersistencePort {
     });
   }
 
-  async findUserById(userId: string) {
-    const user = await this.prisma.user.findUnique({
-      where: { id: userId },
-      include: {
-        profile: true,
-        settings: true,
-        authIdentities: {
-          where: { provider: 'email' },
-          select: { providerId: true },
-          take: 1,
-        },
-      },
-    });
-
-    return user ? this.mapUser(user) : null;
-  }
-
-  async updateUser(input: { userId: string; data: Record<string, unknown> | null }) {
-    const user = await this.prisma.user.update({
-      where: { id: input.userId },
-      data: {
-        data: this.toNullableJson(input.data),
-      },
-      include: {
-        profile: true,
-        settings: true,
-        authIdentities: {
-          where: { provider: 'email' },
-          select: { providerId: true },
-          take: 1,
-        },
-      },
-    });
-
-    return this.mapUser(user);
-  }
-
-  async updateUserProfile(input: {
-    userId: string;
-    name: string | null;
-    avatar: string | null;
-    data: Record<string, unknown> | null;
-  }) {
-    await this.prisma.userProfile.upsert({
-      where: { userId: input.userId },
-      create: {
-        userId: input.userId,
-        name: input.name,
-        avatar: input.avatar,
-        data: this.toNullableJson(input.data),
-      },
-      update: {
-        name: input.name,
-        avatar: input.avatar,
-        data: this.toNullableJson(input.data),
-      },
-    });
-
-    const user = await this.findUserById(input.userId);
-    if (!user) {
-      throw new NotFoundException('User not found');
-    }
-    return user;
-  }
-
-  async updateUserSettings(input: {
-    userId: string;
-    theme: string | null;
-    locale: string | null;
-    data: Record<string, unknown> | null;
-  }) {
-    await this.prisma.userSettings.upsert({
-      where: { userId: input.userId },
-      create: {
-        userId: input.userId,
-        theme: input.theme,
-        locale: input.locale,
-        data: this.toNullableJson(input.data),
-      },
-      update: {
-        theme: input.theme,
-        locale: input.locale,
-        data: this.toNullableJson(input.data),
-      },
-    });
-
-    const user = await this.findUserById(input.userId);
-    if (!user) {
-      throw new NotFoundException('User not found');
-    }
-    return user;
-  }
-
-  async softDeleteUser(userId: string, deletedAt: Date): Promise<void> {
-    await this.prisma.user.update({
-      where: { id: userId },
-      data: {
-        status: 'deleted',
-        deletedAt,
-      },
-    });
-  }
-
   private mapPasswordAccount(user: {
     id: string;
     status: string;
-    data: Prisma.JsonValue | null;
+    data: unknown;
     createdAt: Date;
     updatedAt: Date;
     deletedAt: Date | null;
-    profile: { name: string | null; avatar: string | null; data: Prisma.JsonValue | null } | null;
-    settings: { theme: string | null; locale: string | null; data: Prisma.JsonValue | null } | null;
+    profile: { name: string | null; avatar: string | null; data: unknown } | null;
+    settings: { theme: string | null; locale: string | null; data: unknown } | null;
     authCredential: { passwordHash: string } | null;
     authIdentities: Array<{ provider?: string; providerId: string }>;
   }): PasswordAccountRecord {
     const emailIdentity = user.authIdentities[0];
     return {
-      ...this.mapUser(user),
+      ...mapUserRecord(user),
       provider: 'email',
       providerId: emailIdentity?.providerId ?? '',
       passwordHash: user.authCredential?.passwordHash ?? null,
     };
   }
-
-  private mapUser(user: {
-    id: string;
-    status: string;
-    data: Prisma.JsonValue | null;
-    createdAt: Date;
-    updatedAt: Date;
-    deletedAt: Date | null;
-    profile: { name: string | null; avatar: string | null; data: Prisma.JsonValue | null } | null;
-    settings: { theme: string | null; locale: string | null; data: Prisma.JsonValue | null } | null;
-    authIdentities: Array<{ providerId: string }>;
-  }) {
-    return {
-      id: user.id,
-      email: user.authIdentities[0]?.providerId ?? null,
-      status: user.status,
-      data: this.fromJson(user.data),
-      createdAt: user.createdAt,
-      updatedAt: user.updatedAt,
-      deletedAt: user.deletedAt,
-      profile: user.profile
-        ? {
-            name: user.profile.name,
-            avatar: user.profile.avatar,
-            data: this.fromJson(user.profile.data),
-          }
-        : null,
-      settings: user.settings
-        ? {
-            theme: user.settings.theme,
-            locale: user.settings.locale,
-            data: this.fromJson(user.settings.data),
-          }
-        : null,
-    };
-  }
-
-  private toNullableJson(value: Record<string, unknown> | null) {
-    return value === null ? Prisma.JsonNull : (value as Prisma.InputJsonValue);
-  }
-
-  private fromJson(value: Prisma.JsonValue | null): Record<string, unknown> | null {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-      return null;
-    }
-    return value as Record<string, unknown>;
-  }
 }

package/templates/module-presets/accounts/packages/accounts-api/src/forgeon-accounts.module.ts

@@ -1,4 +1,4 @@
-import {
+import {
   DynamicModule,
   Module,
   ModuleMetadata,
@@ -6,6 +6,7 @@
 } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
+import { DbPrismaModule } from '@forgeon/db-prisma';
 import {
   ACCOUNTS_AUTHZ_CLAIMS_RESOLVER,
   NoopAccountsAuthzClaimsResolver,
@@ -17,12 +18,14 @@ import { AuthCoreService } from './auth-core.service';
 import { AuthJwtService } from './auth-jwt.service';
 import { AuthPasswordService } from './auth-password.service';
 import { AuthService } from './auth.service';
+import { AuthStore } from './auth.store';
 import { JwtAuthGuard } from './access-token.guard';
 import { JwtStrategy } from './jwt.strategy';
 import { OwnerAccessGuard } from './owner-access.guard';
 import { UsersController } from './users.controller';
 import { UsersModule, USERS_MODULE_OPTIONS, type UsersModuleOptions } from './users-config';
 import { UsersService } from './users.service';
+import { UsersStore } from './users.store';
 
 export interface ForgeonAccountsModuleOptions {
   imports?: ModuleMetadata['imports'];
@@ -37,6 +40,7 @@ export class ForgeonAccountsModule {
       module: ForgeonAccountsModule,
       imports: [
         AuthConfigModule,
+        DbPrismaModule,
         PassportModule.register({ defaultStrategy: 'jwt' }),
         JwtModule.register({}),
         ...(options.imports ?? []),
@@ -55,6 +59,8 @@ export class ForgeonAccountsModule {
           provide: ACCOUNTS_AUTHZ_CLAIMS_RESOLVER,
           useClass: NoopAccountsAuthzClaimsResolver,
         },
+        AuthStore,
+        UsersStore,
         AuthCoreService,
         AuthJwtService,
         AuthPasswordService,

package/templates/module-presets/accounts/packages/accounts-api/src/index.ts

@@ -1,5 +1,4 @@
-export * from './accounts-email.port';
-export * from './accounts-persistence.port';
+export * from './accounts-email.port';
 export * from './accounts-rbac.port';
 export * from './auth-config.loader';
 export * from './auth-config.module';
@@ -10,6 +9,7 @@ export * from './auth-env.schema';
 export * from './auth-jwt.service';
 export * from './auth-password.service';
 export * from './auth.service';
+export * from './auth.store';
 export * from './auth.types';
 export * from './dto';
 export * from './forgeon-accounts.module';
@@ -19,6 +19,5 @@ export * from './owner-access.guard';
 export * from './users-config';
 export * from './users.controller';
 export * from './users.service';
+export * from './users.store';
 export * from './users.types';
-
-

package/templates/module-presets/accounts/packages/accounts-api/src/users.service.ts

@@ -1,20 +1,19 @@
 import { Inject, Injectable, NotFoundException } from '@nestjs/common';
 import type { UpdateUserProfileRequest, UpdateUserSettingsRequest, UpdateUserRequest } from '@forgeon/accounts-contracts';
-import { ACCOUNTS_PERSISTENCE_PORT, type AccountsPersistencePort } from './accounts-persistence.port';
 import { USERS_MODULE_OPTIONS, type UsersModuleOptions } from './users-config';
+import { UsersStore } from './users.store';
 import { mergeObjects, normalizeObject, toUserRecordDto } from './users.types';
 
 @Injectable()
 export class UsersService {
   constructor(
-    @Inject(ACCOUNTS_PERSISTENCE_PORT)
-    private readonly persistence: AccountsPersistencePort,
+    private readonly usersStore: UsersStore,
     @Inject(USERS_MODULE_OPTIONS)
     private readonly usersModuleOptions: UsersModuleOptions,
   ) {}
 
   async findById(userId: string) {
-    const user = await this.persistence.findUserById(userId);
+    const user = await this.usersStore.findById(userId);
     return user ? toUserRecordDto(user) : null;
   }
 
@@ -27,12 +26,12 @@ export class UsersService {
   }
 
   async update(userId: string, input: UpdateUserRequest) {
-    const current = await this.persistence.findUserById(userId);
+    const current = await this.usersStore.findById(userId);
     if (!current) {
       throw new NotFoundException('User not found');
     }
 
-    const updated = await this.persistence.updateUser({
+    const updated = await this.usersStore.updateUser({
       userId,
       data: mergeObjects(current.data ?? this.usersModuleOptions.user, input.data),
     });
@@ -40,12 +39,12 @@ export class UsersService {
   }
 
   async updateProfile(userId: string, input: UpdateUserProfileRequest) {
-    const current = await this.persistence.findUserById(userId);
+    const current = await this.usersStore.findById(userId);
     if (!current) {
       throw new NotFoundException('User not found');
     }
 
-    const updated = await this.persistence.updateUserProfile({
+    const updated = await this.usersStore.updateUserProfile({
       userId,
       name: input.name ?? current.profile?.name ?? null,
       avatar: input.avatar ?? current.profile?.avatar ?? null,
@@ -55,12 +54,12 @@ export class UsersService {
   }
 
   async updateSettings(userId: string, input: UpdateUserSettingsRequest) {
-    const current = await this.persistence.findUserById(userId);
+    const current = await this.usersStore.findById(userId);
     if (!current) {
       throw new NotFoundException('User not found');
     }
 
-    const updated = await this.persistence.updateUserSettings({
+    const updated = await this.usersStore.updateUserSettings({
       userId,
       theme: input.theme ?? current.settings?.theme ?? null,
       locale: input.locale ?? current.settings?.locale ?? null,
@@ -70,7 +69,7 @@ export class UsersService {
   }
 
   async softDelete(userId: string): Promise<void> {
-    await this.persistence.softDeleteUser(userId, new Date());
+    await this.usersStore.softDelete(userId, new Date());
   }
 
   resolveUserData(input: unknown) {

package/templates/module-presets/accounts/packages/accounts-api/src/users.store.ts

@@ -0,0 +1,113 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import type { JsonObject } from '@forgeon/accounts-contracts';
+import { PrismaService } from '@forgeon/db-prisma';
+import type { UserRecord } from './users.types';
+import { mapUserRecord, toPrismaJsonInput } from './users.types';
+
+@Injectable()
+export class UsersStore {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findById(userId: string): Promise<UserRecord | null> {
+    const user = await this.prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        profile: true,
+        settings: true,
+        authIdentities: {
+          where: { provider: 'email' },
+          select: { providerId: true },
+          take: 1,
+        },
+      },
+    });
+
+    return user ? mapUserRecord(user) : null;
+  }
+
+  async updateUser(input: { userId: string; data: JsonObject | null }): Promise<UserRecord> {
+    const user = await this.prisma.user.update({
+      where: { id: input.userId },
+      data: {
+        data: toPrismaJsonInput(input.data),
+      },
+      include: {
+        profile: true,
+        settings: true,
+        authIdentities: {
+          where: { provider: 'email' },
+          select: { providerId: true },
+          take: 1,
+        },
+      },
+    });
+
+    return mapUserRecord(user);
+  }
+
+  async updateUserProfile(input: {
+    userId: string;
+    name: string | null;
+    avatar: string | null;
+    data: JsonObject | null;
+  }): Promise<UserRecord> {
+    await this.prisma.userProfile.upsert({
+      where: { userId: input.userId },
+      create: {
+        userId: input.userId,
+        name: input.name,
+        avatar: input.avatar,
+        data: toPrismaJsonInput(input.data),
+      },
+      update: {
+        name: input.name,
+        avatar: input.avatar,
+        data: toPrismaJsonInput(input.data),
+      },
+    });
+
+    const user = await this.findById(input.userId);
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+    return user;
+  }
+
+  async updateUserSettings(input: {
+    userId: string;
+    theme: string | null;
+    locale: string | null;
+    data: JsonObject | null;
+  }): Promise<UserRecord> {
+    await this.prisma.userSettings.upsert({
+      where: { userId: input.userId },
+      create: {
+        userId: input.userId,
+        theme: input.theme,
+        locale: input.locale,
+        data: toPrismaJsonInput(input.data),
+      },
+      update: {
+        theme: input.theme,
+        locale: input.locale,
+        data: toPrismaJsonInput(input.data),
+      },
+    });
+
+    const user = await this.findById(input.userId);
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+    return user;
+  }
+
+  async softDelete(userId: string, deletedAt: Date): Promise<void> {
+    await this.prisma.user.update({
+      where: { id: userId },
+      data: {
+        status: 'deleted',
+        deletedAt,
+      },
+    });
+  }
+}

package/templates/module-presets/accounts/packages/accounts-api/src/users.types.ts

@@ -34,6 +34,54 @@ export function mergeObjects(baseValue: unknown, patchValue: unknown): JsonObjec
   return Object.keys(merged).length > 0 ? merged : null;
 }
 
+export function toPrismaJsonInput(value: JsonObject | null) {
+  return (value ?? undefined) as never;
+}
+
+export function mapUserRecord(source: {
+  id: string;
+  status: string;
+  data: unknown;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt: Date | null;
+  profile?: {
+    name: string | null;
+    avatar: string | null;
+    data: unknown;
+  } | null;
+  settings?: {
+    theme: string | null;
+    locale: string | null;
+    data: unknown;
+  } | null;
+  authIdentities?: Array<{ providerId: string }>;
+}): UserRecord {
+  return {
+    id: source.id,
+    email: source.authIdentities?.[0]?.providerId ?? null,
+    status: source.status,
+    data: normalizeObject(source.data),
+    createdAt: source.createdAt,
+    updatedAt: source.updatedAt,
+    deletedAt: source.deletedAt,
+    profile: source.profile
+      ? {
+          name: source.profile.name,
+          avatar: source.profile.avatar,
+          data: normalizeObject(source.profile.data),
+        }
+      : null,
+    settings: source.settings
+      ? {
+          theme: source.settings.theme,
+          locale: source.settings.locale,
+          data: normalizeObject(source.settings.data),
+        }
+      : null,
+  };
+}
+
 export function toProfileDto(record: UserRecord['profile']): UserProfileDto {
   return {
     name: record?.name ?? null,

package/templates/module-presets/files/packages/files/package.json

@@ -8,6 +8,7 @@
     "build": "tsc -p tsconfig.json"
   },
   "dependencies": {
+    "@forgeon/db-prisma": "workspace:*",
     "@nestjs/common": "^11.0.1",
     "@nestjs/config": "^4.0.0",
     "@nestjs/platform-express": "^11.0.1",