create-forgeon 0.3.9 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-forgeon",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Forgeon project generator CLI",
   "license": "MIT",
   "author": "Forgeon",

package/src/modules/executor.test.mjs

@@ -479,6 +479,13 @@ function assertFilesImageWiring(projectRoot) {
   const filesTypes = fs.readFileSync(path.join(projectRoot, 'packages', 'files', 'src', 'files.types.ts'), 'utf8');
   assert.match(filesTypes, /auditContext\?: \{/);
 
+  const filesImageService = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'files-image', 'src', 'files-image.service.ts'),
+    'utf8',
+  );
+  assert.match(filesImageService, /loadFileTypeModule/);
+  assert.match(filesImageService, /new Function\('specifier', 'return import\(specifier\)'\)/);
+
   const apiDockerfile = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'Dockerfile'), 'utf8');
   assert.match(
     apiDockerfile,
@@ -529,6 +536,10 @@ function assertFilesImageWiring(projectRoot) {
   assert.match(filesImagePackage, /"sharp":/);
   assert.match(filesImagePackage, /"file-type":/);
 
+  const rootPackage = fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8');
+  assert.match(rootPackage, /"onlyBuiltDependencies"/);
+  assert.match(rootPackage, /"sharp"/);
+
   const readme = fs.readFileSync(path.join(projectRoot, 'README.md'), 'utf8');
   assert.match(readme, /## Files Image Module/);
   assert.match(readme, /metadata is stripped before storage/i);

package/src/modules/files-image.mjs

@@ -53,6 +53,29 @@ function patchFilesPackage(targetRoot) {
   writeJson(packagePath, packageJson);
 }
 
+function patchRootPackage(targetRoot) {
+  const packagePath = path.join(targetRoot, 'package.json');
+  if (!fs.existsSync(packagePath)) {
+    return;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  if (!packageJson.pnpm || typeof packageJson.pnpm !== 'object' || Array.isArray(packageJson.pnpm)) {
+    packageJson.pnpm = {};
+  }
+
+  const onlyBuiltDependencies = Array.isArray(packageJson.pnpm.onlyBuiltDependencies)
+    ? packageJson.pnpm.onlyBuiltDependencies
+    : [];
+
+  if (!onlyBuiltDependencies.includes('sharp')) {
+    onlyBuiltDependencies.push('sharp');
+  }
+
+  packageJson.pnpm.onlyBuiltDependencies = onlyBuiltDependencies;
+  writeJson(packagePath, packageJson);
+}
+
 function patchFilesTypes(targetRoot) {
   const filePath = path.join(targetRoot, 'packages', 'files', 'src', 'files.types.ts');
   if (!fs.existsSync(filePath)) {
@@ -526,6 +549,7 @@ export function applyFilesImageModule({ packageRoot, targetRoot }) {
   copyFromPreset(packageRoot, targetRoot, path.join('packages', 'files-image'));
   patchApiPackage(targetRoot);
   patchFilesPackage(targetRoot);
+  patchRootPackage(targetRoot);
   patchFilesTypes(targetRoot);
   patchAppModule(targetRoot);
   patchFilesModule(targetRoot);

package/templates/module-presets/files-image/packages/files-image/src/files-image.service.ts

@@ -15,6 +15,10 @@ const MIME_TO_ALLOWED_EXTS: Record<string, string[]> = {
   'image/webp': ['.webp'],
 };
 
+interface FileTypeModuleLike {
+  fileTypeFromBuffer(buffer: Buffer): Promise<{ mime: string; ext: string } | undefined>;
+}
+
 @Injectable()
 export class FilesImageService {
   private readonly logger = new Logger(FilesImageService.name);
@@ -146,54 +150,89 @@ export class FilesImageService {
     return this.configService.enabled;
   }
 
-  async getProbeStatus(): Promise<{
-    status: 'ok';
-    feature: 'files-image';
-    stripMetadata: boolean;
-    maxWidth: number;
-    maxHeight: number;
-    maxPixels: number;
-    maxFrames: number;
-    inputBytes: number;
-    outputBytes: number;
-    outputMimeType: string;
-    transformed: boolean;
-  }> {
-    const sample = await sharp({
-      create: {
-        width: 4,
-        height: 4,
-        channels: 3,
-        background: { r: 120, g: 80, b: 40 },
-      },
-    })
-      .jpeg({ quality: 90 })
-      .withMetadata()
-      .toBuffer();
-
-    const result = await this.sanitizeForStorage({
-      buffer: sample,
-      declaredMimeType: 'image/jpeg',
-      originalName: 'probe.jpg',
-    });
+  async getProbeStatus(): Promise<
+    | {
+        status: 'ok';
+        feature: 'files-image';
+        stripMetadata: boolean;
+        maxWidth: number;
+        maxHeight: number;
+        maxPixels: number;
+        maxFrames: number;
+        inputBytes: number;
+        outputBytes: number;
+        outputMimeType: string;
+        transformed: boolean;
+      }
+    | {
+        status: 'error';
+        feature: 'files-image';
+        stripMetadata: boolean;
+        maxWidth: number;
+        maxHeight: number;
+        maxPixels: number;
+        maxFrames: number;
+        errorCode: string;
+        errorMessage: string;
+      }
+  > {
+    try {
+      const sample = await sharp({
+        create: {
+          width: 4,
+          height: 4,
+          channels: 3,
+          background: { r: 120, g: 80, b: 40 },
+        },
+      })
+        .jpeg({ quality: 90 })
+        .withMetadata()
+        .toBuffer();
+
+      const result = await this.sanitizeForStorage({
+        buffer: sample,
+        declaredMimeType: 'image/jpeg',
+        originalName: 'probe.jpg',
+      });
 
-    return {
-      status: 'ok',
-      feature: 'files-image',
-      stripMetadata: this.configService.stripMetadata,
-      maxWidth: this.configService.maxWidth,
-      maxHeight: this.configService.maxHeight,
-      maxPixels: this.configService.maxPixels,
-      maxFrames: this.configService.maxFrames,
-      inputBytes: sample.byteLength,
-      outputBytes: result.buffer.byteLength,
-      outputMimeType: result.mimeType,
-      transformed: result.transformed,
-    };
+      return {
+        status: 'ok',
+        feature: 'files-image',
+        stripMetadata: this.configService.stripMetadata,
+        maxWidth: this.configService.maxWidth,
+        maxHeight: this.configService.maxHeight,
+        maxPixels: this.configService.maxPixels,
+        maxFrames: this.configService.maxFrames,
+        inputBytes: sample.byteLength,
+        outputBytes: result.buffer.byteLength,
+        outputMimeType: result.mimeType,
+        transformed: result.transformed,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown files-image probe error';
+      this.logger.error(
+        JSON.stringify({
+          event: 'files.image.probe_failed',
+          errorMessage,
+        }),
+      );
+
+      return {
+        status: 'error',
+        feature: 'files-image',
+        stripMetadata: this.configService.stripMetadata,
+        maxWidth: this.configService.maxWidth,
+        maxHeight: this.configService.maxHeight,
+        maxPixels: this.configService.maxPixels,
+        maxFrames: this.configService.maxFrames,
+        errorCode: 'FILES_IMAGE_PROBE_FAILED',
+        errorMessage,
+      };
+    }
   }
 
   private async detectFileType(buffer: Buffer): Promise<{ mime: string; ext: string } | null> {
-    const { fileTypeFromBuffer } = await import('file-type');
+    const { fileTypeFromBuffer } = await this.loadFileTypeModule();
     const detected = await fileTypeFromBuffer(buffer);
     if (!detected) {
       return null;
@@ -267,6 +306,13 @@ export class FilesImageService {
     }
   }
 
+  private async loadFileTypeModule(): Promise<FileTypeModuleLike> {
+    const importModule = new Function('specifier', 'return import(specifier)') as (
+      specifier: string,
+    ) => Promise<FileTypeModuleLike>;
+    return importModule('file-type');
+  }
+
   private async validateImageShape(
     buffer: Buffer,
     detectedMimeType: string,