create-forgeon 0.3.8 → 0.3.10

package/package.json

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

package/src/modules/executor.test.mjs

@@ -440,6 +440,7 @@ function assertFilesImageWiring(projectRoot) {
   const appModule = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'src', 'app.module.ts'), 'utf8');
   assert.match(appModule, /filesImageConfig/);
   assert.match(appModule, /filesImageEnvSchema/);
+  assert.match(appModule, /ForgeonFilesImageModule/);
 
   const apiPackage = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'package.json'), 'utf8');
   assert.match(apiPackage, /@forgeon\/files-image/);
@@ -528,6 +529,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)) {
@@ -84,11 +107,31 @@ function patchAppModule(targetRoot) {
   let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
   content = ensureImportLine(
     content,
-    "import { filesImageConfig, filesImageEnvSchema } from '@forgeon/files-image';",
+    "import { filesImageConfig, filesImageEnvSchema, ForgeonFilesImageModule } from '@forgeon/files-image';",
   );
   content = ensureLoadItem(content, 'filesImageConfig');
   content = ensureValidatorSchema(content, 'filesImageEnvSchema');
 
+  if (!content.includes('    ForgeonFilesImageModule,')) {
+    if (content.includes('    ForgeonI18nModule.register({')) {
+      content = ensureLineBefore(content, '    ForgeonI18nModule.register({', '    ForgeonFilesImageModule,');
+    } else if (content.includes('    ForgeonAuthModule.register({')) {
+      content = ensureLineBefore(content, '    ForgeonAuthModule.register({', '    ForgeonFilesImageModule,');
+    } else if (content.includes('    ForgeonAuthModule.register(),')) {
+      content = ensureLineBefore(content, '    ForgeonAuthModule.register(),', '    ForgeonFilesImageModule,');
+    } else if (content.includes('    ForgeonFilesModule,')) {
+      content = ensureLineAfter(content, '    ForgeonFilesModule,', '    ForgeonFilesImageModule,');
+    } else if (content.includes('    DbPrismaModule,')) {
+      content = ensureLineAfter(content, '    DbPrismaModule,', '    ForgeonFilesImageModule,');
+    } else if (content.includes('    ForgeonLoggerModule,')) {
+      content = ensureLineAfter(content, '    ForgeonLoggerModule,', '    ForgeonFilesImageModule,');
+    } else if (content.includes('    ForgeonSwaggerModule,')) {
+      content = ensureLineAfter(content, '    ForgeonSwaggerModule,', '    ForgeonFilesImageModule,');
+    } else {
+      content = ensureLineAfter(content, '    CoreErrorsModule,', '    ForgeonFilesImageModule,');
+    }
+  }
+
   fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
 }
 
@@ -506,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

@@ -146,50 +146,85 @@ 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> {