create-forgeon 0.3.18 → 0.3.20

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",

package/templates/module-presets/files/packages/files/src/files.ports.ts

@@ -1,102 +1,7 @@
 import { Readable } from 'node:stream';
-import type { FileVariantKey } from './files.types';
 
-export const FILES_PERSISTENCE_PORT = 'FORGEON_FILES_PERSISTENCE_PORT';
 export const FILES_STORAGE_ADAPTER = 'FORGEON_FILES_STORAGE_ADAPTER';
 
-export type FilesBlobRecord = {
-  id: string;
-  hash: string;
-  size: number;
-  mimeType: string;
-  storageDriver: string;
-  storageKey: string;
-};
-
-export type FilesBlobRef = FilesBlobRecord & {
-  created: boolean;
-};
-
-export type FilesRecordVariant = {
-  variantKey: string;
-  blobId: string;
-  mimeType: string;
-  size: number;
-  status: string;
-  blob?: {
-    storageDriver: string;
-    storageKey: string;
-  };
-};
-
-export type FilesRecordAggregate = {
-  id: string;
-  publicId: string;
-  storageKey: string;
-  originalName: string;
-  mimeType: string;
-  size: number;
-  storageDriver: string;
-  ownerType: string;
-  ownerId: string | null;
-  visibility: string;
-  createdById: string | null;
-  createdAt: Date;
-  updatedAt: Date;
-  variants?: FilesRecordVariant[];
-};
-
-export type FilesRecordCreateInput = {
-  publicId: string;
-  storageKey: string;
-  originalName: string;
-  mimeType: string;
-  size: number;
-  storageDriver: string;
-  ownerType: string;
-  ownerId: string | null;
-  visibility: string;
-  createdById: string | null;
-};
-
-export type FilesBlobCreateInput = {
-  hash: string;
-  size: number;
-  mimeType: string;
-  storageDriver: string;
-  storageKey: string;
-};
-
-export type FilesVariantCreateInput = {
-  fileId: string;
-  variantKey: FileVariantKey;
-  blobId: string;
-  mimeType: string;
-  size: number;
-  status: string;
-};
-
-export interface FilesPersistencePort {
-  createFileRecord(data: FilesRecordCreateInput): Promise<{
-    id: string;
-    publicId: string;
-  }>;
-  deleteFileRecordById(id: string): Promise<void>;
-  deleteFileRecordByPublicId(publicId: string): Promise<void>;
-  findFileRecordWithVariantKeys(publicId: string): Promise<FilesRecordAggregate | null>;
-  findFileRecordForDelete(publicId: string): Promise<FilesRecordAggregate | null>;
-  findFileRecordForDownload(publicId: string): Promise<FilesRecordAggregate | null>;
-  countOwnerUsage(ownerType: string, ownerId: string): Promise<{
-    filesCount: number;
-    totalBytes: number;
-  }>;
-  findBlobRef(hash: string, size: number, mimeType: string, storageDriver: string): Promise<FilesBlobRef | null>;
-  createBlob(data: FilesBlobCreateInput): Promise<FilesBlobRecord>;
-  createVariants(data: FilesVariantCreateInput[]): Promise<void>;
-  findBlobById(id: string): Promise<FilesBlobRecord | null>;
-  deleteBlobIfUnreferenced(id: string): Promise<boolean>;
-}
-
 export interface FilesStorageAdapter {
   readonly driver: string;
   put(buffer: Buffer, fileName: string): Promise<{