@solidxai/core 0.1.12-beta.7 → 0.1.12-beta.9

package/src/seeders/seed-data/solid-core-metadata.json

@@ -1704,18 +1704,6 @@
             "columnName": "original_file_name",
             "isSystem": true
           },
-          {
-            "name": "isPublic",
-            "displayName": "Is Public",
-            "type": "boolean",
-            "required": false,
-            "unique": false,
-            "index": false,
-            "private": false,
-            "encrypt": false,
-            "columnName": "is_public",
-            "isSystem": true
-          },
           {
             "name": "modelMetadata",
             "displayName": "Model Metadata",
@@ -8789,13 +8777,6 @@
               "sortable": false
             }
           },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "isPublic",
-              "sortable": true
-            }
-          },
           {
             "type": "field",
             "attrs": {
@@ -8891,14 +8872,6 @@
                   "isSearchable": true
                 }
               },
-              {
-                "type": "field",
-                "attrs": {
-                  "name": "isPublic",
-                  "label": "isPublic",
-                  "isSearchable": true
-                }
-              },
               {
                 "type": "field",
                 "attrs": {
@@ -8967,12 +8940,6 @@
                       "name": "mediaStorageProviderMetadata"
                     }
                   },
-                  {
-                    "type": "field",
-                    "attrs": {
-                      "name": "isPublic"
-                    }
-                  },
                   {
                     "type": "field",
                     "attrs": {
@@ -14581,12 +14548,6 @@
       "isPublic": true,
       "localPath": "media-files-storage"
     },
-    {
-      "name": "private-filesystem",
-      "type": "filesystem",
-      "isPublic": false,
-      "localPath": "media-private-files-storage"
-    },
     {
       "name": "default-aws-s3",
       "type": "aws-s3"

package/src/services/authentication.service.ts

@@ -212,6 +212,7 @@ export class AuthenticationService {
         effectiveDto,
         entity,
         provider.repo as Repository<User>,
+        true,
       );
     }
     return this.performSignUp(signUpDto, new User(), this.userRepository);
@@ -221,6 +222,7 @@ export class AuthenticationService {
     signUpDto: SignUpDto,
     entity: T,
     repo: Repository<T>,
+    preferEntityApiKeyFlag: boolean = false,
   ): Promise<T> {
     try {
       const onForcePasswordChange =
@@ -241,7 +243,10 @@ export class AuthenticationService {
         onForcePasswordChange,
       );
       const privateDto = signUpDto as { isAllowedToGenerateApiKeys?: boolean };
-      if (privateDto.isAllowedToGenerateApiKeys !== undefined) {
+      if (
+        !preferEntityApiKeyFlag &&
+        privateDto.isAllowedToGenerateApiKeys !== undefined
+      ) {
         user.isAllowedToGenerateApiKeys = privateDto.isAllowedToGenerateApiKeys;
       }
       const savedUser = await repo.save(user);

package/src/services/media-download-url.service.ts

@@ -1,12 +1,12 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
 import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
-import { S3FileService } from 'src/services/file';
-import { getEffectiveS3Region } from 'src/services/media-storage.utils';
 import { SettingService } from 'src/services/setting.service';
 import type { SolidCoreSetting } from 'src/services/settings/default-settings-provider.service';
+import { getEffectiveS3Region } from './media-storage.utils';
+import { ConfigService } from '@nestjs/config';
+import { S3FileService } from './file';
 
 export const MEDIA_DOWNLOAD_TOKEN_AUDIENCE = 'media-download';
 const DEFAULT_SIGNED_URL_EXPIRY_MINUTES = 60;
@@ -26,10 +26,14 @@ export class MediaDownloadUrlService {
     private readonly configService: ConfigService,
   ) { }
 
-  async resolveDownloadUrl(mediaId: number, relativeUri: string, storageProvider?: MediaStorageProviderMetadata): Promise<string> {
+  async resolveDownloadUrl(
+    mediaId: number,
+    relativeUri: string,
+    storageProvider?: MediaStorageProviderMetadata,
+  ): Promise<string> {
     const expiryMinutes = storageProvider?.signedUrlExpiry ?? DEFAULT_SIGNED_URL_EXPIRY_MINUTES;
 
-    if ((storageProvider?.type as MediaStorageProviderType) === MediaStorageProviderType.AwsS3) {
+      if ((storageProvider?.type as MediaStorageProviderType) === MediaStorageProviderType.AwsS3) {
       if (storageProvider?.bucketName) {
         return this.s3FileService.getUrl(
           `${storageProvider.bucketName}:${relativeUri}`,
@@ -38,7 +42,6 @@ export class MediaDownloadUrlService {
       }
       this.logger.warn(`Media id ${mediaId}: AwsS3 provider missing bucketName; falling back to app-hosted token URL`);
     }
-
     // Filesystem (or misconfigured S3) has no native presigned-URL mechanism, so mint our
     // own short-lived token and embed it in the download URL - the token alone authorizes
     // the request (see MediaSignedUrlGuard), so it works in a plain <img src> with no
@@ -49,6 +52,10 @@ export class MediaDownloadUrlService {
     return `${String(baseUrl).replace(/\/+$/, '')}${downloadPath}`;
   }
 
+  async getPrivateUrl(mediaId: number, relativeUri: string, storageProvider?: MediaStorageProviderMetadata): Promise<string> {
+    return this.resolveDownloadUrl(mediaId, relativeUri, storageProvider);
+  }
+
   async verifyDownloadToken(token: string): Promise<MediaDownloadTokenPayload> {
     return this.jwtService.verifyAsync<MediaDownloadTokenPayload>(token, {
       secret: this.settingService.getConfigValue<SolidCoreSetting>('secret'),

package/src/services/media-storage.utils.ts

@@ -6,7 +6,6 @@ import { SettingService } from 'src/services/setting.service';
 import { DEFAULT_MEDIA_FILE_STORAGE_DIR } from 'src/services/settings/default-settings-provider.service';
 import type { SolidCoreSetting } from 'src/services/settings/default-settings-provider.service';
 
-export const DEFAULT_PRIVATE_MEDIA_STORAGE_DIR = 'media-private-files-storage';
 
 export interface MediaRecordCreateInput {
   entityId: number;
@@ -17,7 +16,6 @@ export interface MediaRecordCreateInput {
   mimeType?: string;
   fileSize?: number;
   originalFileName?: string;
-  isPublic?: boolean;
 }
 
 // Builds the stored file name format shared by media storage implementations.
@@ -28,8 +26,10 @@ export function buildStoredMediaFileName(file: Pick<Express.Multer.File, 'filena
 // Resolves the on-disk path for a media file based on settings and provider visibility.
 export function buildDiskMediaPath(fileName: string,settingService: Pick<SettingService, 'getConfigValue'>,storageProvider?: Pick<MediaStorageProviderMetadata, 'localPath' | 'isPublic'>,): string {
   const publicBase = settingService.getConfigValue<SolidCoreSetting>('fileStorageDir') || DEFAULT_MEDIA_FILE_STORAGE_DIR;
-  const privateBase = DEFAULT_PRIVATE_MEDIA_STORAGE_DIR;
-  const providerBase = storageProvider?.localPath || (storageProvider?.isPublic === false ? privateBase : publicBase);
+  const privateBase = `${publicBase}-private`;
+  // const localPath = storageProvider?.localPath;
+  // const isUsingLegacyDefaultPath = localPath === publicBase || localPath === privateBase || localPath === privateBase;
+  const providerBase = storageProvider?.isPublic === false ? privateBase : publicBase
 
   if ( path.isAbsolute(fileName) || fileName.startsWith(`${publicBase}/`) || fileName.startsWith(`${privateBase}/`) || (!!storageProvider?.localPath && fileName.startsWith(`${storageProvider.localPath}/`))) {
     return fileName;
@@ -39,12 +39,12 @@ export function buildDiskMediaPath(fileName: string,settingService: Pick<Setting
 }
 
 // Returns the S3 region from the provider when present, otherwise falls back to app config.
-export function getEffectiveS3Region(configService: Pick<ConfigService, 'get'>,providerRegion?: string,): string | undefined {
+export function getEffectiveS3Region(configService: Pick<ConfigService, 'get'>, providerRegion?: string): string | undefined {
   return providerRegion || configService.get<string>('S3_AWS_REGION_NAME');
 }
 
 // Resolves the effective public/private flag for a media storage provider.
-export function resolveMediaIsPublic(storageProvider?: Pick<MediaStorageProviderMetadata, 'isPublic'>,): boolean | undefined {
+export function resolveMediaIsPublic(storageProvider?: Pick<MediaStorageProviderMetadata, 'isPublic'>): boolean | undefined {
   if (!storageProvider) {
     return undefined;
   }
@@ -52,15 +52,6 @@ export function resolveMediaIsPublic(storageProvider?: Pick<MediaStorageProvider
   return storageProvider.isPublic !== false;
 }
 
-// Preserves an explicit media visibility value or derives it from the storage provider.
-export function resolveStoredMediaIsPublic(currentValue: boolean | undefined,storageProvider?:Pick<MediaStorageProviderMetadata, 'isPublic'>,): boolean | undefined {
-  if (typeof currentValue === 'boolean') {
-    return currentValue;
-  }
-
-  return resolveMediaIsPublic(storageProvider);
-}
-
 // Builds the shared media record payload used before saving media metadata to the database.
 export function buildMediaRecordCreateInput(
   entityId: number,

package/src/services/media.service.ts

@@ -20,7 +20,7 @@ import { FieldMetadataRepository } from 'src/repository/field-metadata.repositor
 import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
 import { MediaRepository } from 'src/repository/media.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { buildDiskMediaPath, buildStoredMediaFileName, getEffectiveS3Region, resolveStoredMediaIsPublic, } from 'src/services/media-storage.utils';
+import { buildDiskMediaPath, buildStoredMediaFileName, getEffectiveS3Region, resolveMediaIsPublic, } from 'src/services/media-storage.utils';
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 
 @Injectable()
@@ -131,10 +131,9 @@ export class MediaService extends CRUDService<Media> {
       // Delete temp file from disk
       await this.diskFileService.delete(file.path);
 
-      createDto['isPublic'] = resolveStoredMediaIsPublic(createDto['isPublic'], storageProvider);
+      delete createDto['isPublic'];
       const media = this.repo.create(createDto as Partial<Media>) as Media;
       const savedMedia = await this.repo.save(media);
-      savedMedia.isPublic = resolveStoredMediaIsPublic(savedMedia.isPublic, storageProvider);
       savedMedias.push(savedMedia)
     }
     return savedMedias
@@ -228,16 +227,15 @@ export class MediaService extends CRUDService<Media> {
 
   private async decorateMediaRecord(media: Media): Promise<void> {
     const mediaStorageProvider = await this.resolveMediaStorageProvider(media);
-    media.isPublic = resolveStoredMediaIsPublic(media.isPublic, mediaStorageProvider);
     media.relativeUri = await this.resolveMediaUrl(media, mediaStorageProvider);
   }
 
   private async resolveMediaUrl(media: Media, mediaStorageProvider?: MediaStorageProviderMetadata): Promise<string> {
     const resolvedMediaStorageProvider = mediaStorageProvider || await this.resolveMediaStorageProvider(media);
-    const isPublic = resolveStoredMediaIsPublic(media.isPublic, resolvedMediaStorageProvider);
+    const isPublic = resolveMediaIsPublic(resolvedMediaStorageProvider);
 
     if (isPublic === false) {
-      return this.mediaDownloadUrlService.resolveDownloadUrl(media.id, media.relativeUri, resolvedMediaStorageProvider);
+      return this.mediaDownloadUrlService.getPrivateUrl(media.id, media.relativeUri, resolvedMediaStorageProvider);
     }
 
     if (resolvedMediaStorageProvider?.type === MediaStorageProviderType.Filesystem) {

package/src/services/mediaStorageProviders/file-s3-storage-provider.ts

@@ -11,10 +11,10 @@ import { Readable } from "stream";
 import { MediaRepository } from "src/repository/media.repository";
 import { MediaDownloadUrlService } from "src/services/media-download-url.service";
 import {
-    buildMediaRecordCreateInput,
-    buildStoredMediaFileName,
-    getEffectiveS3Region,
-    resolveStoredMediaIsPublic,
+buildMediaRecordCreateInput,
+buildStoredMediaFileName,
+getEffectiveS3Region,
+resolveMediaIsPublic,
 } from "src/services/media-storage.utils";
 
 @Injectable()
@@ -54,7 +54,6 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
                     fileSize,
                 })
             ) as unknown as Media;
-            mediaEntity.isPublic = resolveStoredMediaIsPublic(mediaEntity.isPublic, storageProvider);
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
         }
@@ -71,10 +70,9 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         // Add the full URL to the media
         for (const m of media) {
             const storageMeta = m.mediaStorageProviderMetadata;
-            const isPublic = resolveStoredMediaIsPublic(m.isPublic, storageMeta);
-            m.isPublic = isPublic;
+            const isPublic = resolveMediaIsPublic(storageMeta);
             m['_full_url'] = isPublic === false
-                ? await this.mediaDownloadUrlService.resolveDownloadUrl(m.id, m.relativeUri, storageMeta)
+                ? await this.mediaDownloadUrlService.getPrivateUrl(m.id, m.relativeUri, storageMeta)
                 : await this.s3FileService.getUrl(
                     `${storageMeta.bucketName}:${m.relativeUri}`,
                     { region: getEffectiveS3Region(this.configService, storageMeta.region), expiresIn: 0 },
@@ -116,7 +114,6 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
                     originalFileName: file.originalname,
                 })
             ) as unknown as Media;
-            mediaEntity.isPublic = resolveStoredMediaIsPublic(mediaEntity.isPublic, storageProvider);
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
         };

package/src/services/mediaStorageProviders/file-storage-provider.ts

@@ -9,7 +9,7 @@ import { Readable } from "stream";
 import * as fs from "fs";
 import { SettingService } from "../setting.service";
 import { MediaDownloadUrlService } from "src/services/media-download-url.service";
-import { buildDiskMediaPath, buildMediaRecordCreateInput, buildStoredMediaFileName, resolveStoredMediaIsPublic, } from "src/services/media-storage.utils";
+import {buildDiskMediaPath,buildMediaRecordCreateInput,buildStoredMediaFileName,resolveMediaIsPublic,} from "src/services/media-storage.utils";
 
 @Injectable()
 export class FileStorageProvider<T> implements MediaStorageProvider<T> {
@@ -34,10 +34,9 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
         // });
         for (const m of media) {
             const storageProvider = this.resolveMediaStorageProvider(m, mediaFieldMetadata);
-            const isPublic = resolveStoredMediaIsPublic(m.isPublic, storageProvider);
-            m.isPublic = isPublic;
+            const isPublic = resolveMediaIsPublic(storageProvider);
             m['_full_url'] = isPublic === false
-                ? await this.mediaDownloadUrlService.resolveDownloadUrl(m.id, m.relativeUri, storageProvider)
+                ? await this.mediaDownloadUrlService.getPrivateUrl(m.id, m.relativeUri, storageProvider)
                 : await this.fileService.getUrl(buildDiskMediaPath(m.relativeUri, this.settingService, storageProvider));
         }
 
@@ -67,7 +66,6 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
                     originalFileName: file.originalname,
                 })
             ) as unknown as Media;
-            mediaEntity.isPublic = resolveStoredMediaIsPublic(mediaEntity.isPublic, storageProvider);
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
         };
@@ -92,7 +90,6 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
                     fileSize,
                 })
             ) as unknown as Media;
-            mediaEntity.isPublic = resolveStoredMediaIsPublic(mediaEntity.isPublic, storageProvider);
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
         };