create-forgeon 0.3.15 → 0.3.17

package/templates/module-presets/files/apps/api/src/files/prisma-files-persistence.store.ts

@@ -0,0 +1,164 @@
+import {
+  FILES_PERSISTENCE_PORT,
+  type FilesBlobCreateInput,
+  type FilesBlobRef,
+  type FilesPersistencePort,
+  type FilesRecordAggregate,
+  type FilesRecordCreateInput,
+  type FilesVariantCreateInput,
+} from '@forgeon/files';
+import { PrismaService } from '@forgeon/db-prisma';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class PrismaFilesPersistenceStore implements FilesPersistencePort {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async createFileRecord(data: FilesRecordCreateInput): Promise<{ id: string; publicId: string }> {
+    const record = await this.prisma.fileRecord.create({ data });
+    return {
+      id: record.id,
+      publicId: record.publicId,
+    };
+  }
+
+  async deleteFileRecordById(id: string): Promise<void> {
+    await this.prisma.fileRecord.delete({ where: { id } });
+  }
+
+  async deleteFileRecordByPublicId(publicId: string): Promise<void> {
+    await this.prisma.fileRecord.delete({ where: { publicId } });
+  }
+
+  async findFileRecordWithVariantKeys(publicId: string): Promise<FilesRecordAggregate | null> {
+    return this.prisma.fileRecord.findUnique({
+      where: { publicId },
+      include: {
+        variants: {
+          select: {
+            variantKey: true,
+            blobId: true,
+            mimeType: true,
+            size: true,
+            status: true,
+          },
+        },
+      },
+    });
+  }
+
+  async findFileRecordForDelete(publicId: string): Promise<FilesRecordAggregate | null> {
+    return this.prisma.fileRecord.findUnique({
+      where: { publicId },
+      include: {
+        variants: {
+          select: {
+            variantKey: true,
+            blobId: true,
+            mimeType: true,
+            size: true,
+            status: true,
+            blob: {
+              select: {
+                storageDriver: true,
+                storageKey: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  async findFileRecordForDownload(publicId: string): Promise<FilesRecordAggregate | null> {
+    return this.prisma.fileRecord.findUnique({
+      where: { publicId },
+      include: {
+        variants: {
+          select: {
+            variantKey: true,
+            blobId: true,
+            mimeType: true,
+            size: true,
+            status: true,
+            blob: {
+              select: {
+                storageDriver: true,
+                storageKey: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  async countOwnerUsage(ownerType: string, ownerId: string): Promise<{ filesCount: number; totalBytes: number }> {
+    const aggregate = await this.prisma.fileRecord.aggregate({
+      where: {
+        ownerType,
+        ownerId,
+      },
+      _count: {
+        _all: true,
+      },
+      _sum: {
+        size: true,
+      },
+    });
+
+    return {
+      filesCount: aggregate._count._all ?? 0,
+      totalBytes: aggregate._sum.size ?? 0,
+    };
+  }
+
+  async findBlobRef(hash: string, size: number, mimeType: string, storageDriver: string): Promise<FilesBlobRef | null> {
+    const existing = await this.prisma.fileBlob.findFirst({
+      where: {
+        hash,
+        size,
+        mimeType,
+        storageDriver,
+      },
+    });
+    if (!existing) {
+      return null;
+    }
+    return {
+      id: existing.id,
+      hash: existing.hash,
+      size: existing.size,
+      mimeType: existing.mimeType,
+      storageDriver: existing.storageDriver,
+      storageKey: existing.storageKey,
+      created: false,
+    };
+  }
+
+  async createBlob(data: FilesBlobCreateInput) {
+    return this.prisma.fileBlob.create({ data });
+  }
+
+  async createVariants(data: FilesVariantCreateInput[]): Promise<void> {
+    await this.prisma.fileVariant.createMany({ data });
+  }
+
+  async findBlobById(id: string) {
+    return this.prisma.fileBlob.findUnique({
+      where: { id },
+    });
+  }
+
+  async deleteBlobIfUnreferenced(id: string): Promise<boolean> {
+    const deleted = await this.prisma.fileBlob.deleteMany({
+      where: {
+        id,
+        variants: {
+          none: {},
+        },
+      },
+    });
+    return deleted.count > 0;
+  }
+}

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

@@ -8,7 +8,6 @@
     "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",
@@ -21,4 +20,4 @@
     "@types/node": "^22.10.7",
     "typescript": "^5.7.3"
   }
-}
+}

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

@@ -0,0 +1,107 @@
+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<{
+    storageKey: string;
+  }>;
+  open(storageKey: string): Promise<Readable>;
+  delete(storageKey: string): Promise<void>;
+}