cabloy 5.1.97 → 5.1.99

package/vona/src/suite-vendor/a-file/modules/file-cloudflare/src/service/fileCloudflare.ts

@@ -0,0 +1,245 @@
+import type {
+  EntityFile,
+  IFileDeliveryOptions,
+  IFileDirectUploadInput,
+  IFileProviderDirectUploadResource,
+  IFileProviderResource,
+  IFileUploadInput,
+  IFileUploadUrlInput,
+} from 'vona-module-a-file';
+
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import fse from 'fs-extra';
+import path from 'node:path';
+import { BeanBase, uuidv4 } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { IFileProviderCloudflareClientOptions } from '../bean/fileProvider.cloudflare.ts';
+
+interface IFileCloudflareClientOptionsNormalized extends IFileProviderCloudflareClientOptions {
+  endpoint: string;
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  bucket: string;
+}
+
+@Service()
+export class ServiceFileCloudflare extends BeanBase {
+  async upload(
+    input: IFileUploadInput,
+    options: IFileProviderCloudflareClientOptions,
+  ): Promise<IFileProviderResource> {
+    const normalized = this._normalizeClientOptions(options);
+    const objectKey = input.objectKey ?? this._createObjectKey(input.filename);
+    const body = await fse.readFile(input.file);
+    const command = new PutObjectCommand({
+      Bucket: normalized.bucket,
+      Key: objectKey,
+      Body: body,
+      ContentType: input.contentType,
+    });
+    const result = await this._getClient(normalized).send(command);
+    const stat = await fse.stat(input.file);
+    return {
+      resourceId: uuidv4(),
+      bucket: normalized.bucket,
+      objectKey,
+      filename: input.filename ?? path.basename(objectKey),
+      contentType: input.contentType,
+      size: input.size ?? Number(stat.size),
+      etag: this._normalizeEtag(result.ETag),
+      deliveryBaseUrl: normalized.deliveryBaseUrl,
+      public: input.public ?? normalized.public,
+      meta: input.meta,
+      raw: result,
+    };
+  }
+
+  async uploadUrl(
+    input: IFileUploadUrlInput,
+    options: IFileProviderCloudflareClientOptions,
+  ): Promise<IFileProviderResource> {
+    const response = await fetch(input.url);
+    if (!response.ok) {
+      throw new Error(`Remote file fetch failed: ${response.status}`);
+    }
+    const tempDir = await this.app.util.getPublicPathPhysical('.temp-file-cloudflare', true);
+    const tempFile = path.join(
+      tempDir,
+      `${uuidv4()}${path.extname(input.filename ?? new URL(input.url).pathname)}`,
+    );
+    const arrayBuffer = await response.arrayBuffer();
+    await fse.writeFile(tempFile, Buffer.from(arrayBuffer));
+    try {
+      return await this.upload(
+        {
+          file: tempFile,
+          filename: input.filename ?? path.basename(new URL(input.url).pathname),
+          contentType: input.contentType ?? response.headers.get('content-type') ?? undefined,
+          size: input.size,
+          objectKey: input.objectKey,
+          public: input.public,
+          meta: input.meta,
+        },
+        options,
+      );
+    } finally {
+      await fse.remove(tempFile);
+    }
+  }
+
+  async createDirectUpload(
+    input: IFileDirectUploadInput,
+    options: IFileProviderCloudflareClientOptions,
+  ): Promise<IFileProviderDirectUploadResource> {
+    const normalized = this._normalizeClientOptions(options);
+    const objectKey = input.objectKey ?? this._createObjectKey(input.filename);
+    const command = new PutObjectCommand({
+      Bucket: normalized.bucket,
+      Key: objectKey,
+      ContentType: input.contentType,
+    });
+    const uploadUrl = await getSignedUrl(this._getClient(normalized), command, {
+      expiresIn: this._resolveExpiresIn(input.expiry, normalized.presignExpiresIn ?? 600),
+    });
+    return {
+      resourceId: uuidv4(),
+      bucket: normalized.bucket,
+      objectKey,
+      filename: input.filename ?? path.basename(objectKey),
+      contentType: input.contentType,
+      size: input.size,
+      deliveryBaseUrl: normalized.deliveryBaseUrl,
+      public: input.public ?? normalized.public,
+      meta: input.meta,
+      uploadUrl,
+      method: 'PUT',
+      headers: input.contentType ? { 'content-type': input.contentType } : undefined,
+    };
+  }
+
+  async remove(
+    file: Pick<EntityFile, 'bucket' | 'objectKey'>,
+    options: IFileProviderCloudflareClientOptions,
+  ) {
+    const normalized = this._normalizeClientOptions(options);
+    if (!file.objectKey) return;
+    await this._getClient(normalized).send(
+      new DeleteObjectCommand({
+        Bucket: file.bucket ?? normalized.bucket,
+        Key: file.objectKey,
+      }),
+    );
+  }
+
+  async getDownloadUrl(
+    file: Pick<EntityFile, 'bucket' | 'objectKey' | 'deliveryBaseUrl' | 'public'>,
+    options: IFileProviderCloudflareClientOptions,
+    deliveryOptions?: IFileDeliveryOptions,
+  ) {
+    const normalized = this._normalizeClientOptions(options);
+    const bucket = file.bucket ?? normalized.bucket;
+    const objectKey = file.objectKey;
+    if (!objectKey) {
+      throw new Error('File objectKey is required');
+    }
+    const isPublic = file.public ?? normalized.public;
+    const deliveryBaseUrl = file.deliveryBaseUrl ?? normalized.deliveryBaseUrl;
+    if (isPublic && deliveryBaseUrl) {
+      return this._buildPublicUrl(deliveryBaseUrl, objectKey);
+    }
+    const command = new GetObjectCommand({
+      Bucket: bucket,
+      Key: objectKey,
+    });
+    return await getSignedUrl(this._getClient(normalized), command, {
+      expiresIn: deliveryOptions?.expiresIn ?? normalized.presignExpiresIn ?? 600,
+    });
+  }
+
+  async getMetadata(
+    file: Pick<EntityFile, 'bucket' | 'objectKey'>,
+    options: IFileProviderCloudflareClientOptions,
+  ) {
+    const normalized = this._normalizeClientOptions(options);
+    if (!file.objectKey) return undefined;
+    return await this._getClient(normalized).send(
+      new HeadObjectCommand({
+        Bucket: file.bucket ?? normalized.bucket,
+        Key: file.objectKey,
+      }),
+    );
+  }
+
+  private _normalizeClientOptions(options: IFileProviderCloudflareClientOptions) {
+    const endpoint = options.endpoint;
+    const accessKeyId = options.accessKeyId;
+    const secretAccessKey = options.secretAccessKey;
+    const bucket = options.bucket;
+    if (!endpoint) throw new Error('Cloudflare R2 endpoint is required');
+    if (!accessKeyId) throw new Error('Cloudflare R2 accessKeyId is required');
+    if (!secretAccessKey) throw new Error('Cloudflare R2 secretAccessKey is required');
+    if (!bucket) throw new Error('Cloudflare R2 bucket is required');
+    return {
+      ...options,
+      endpoint: endpoint.replace(/\/$/, ''),
+      region: options.region ?? 'auto',
+      accessKeyId,
+      secretAccessKey,
+      bucket,
+    } as IFileCloudflareClientOptionsNormalized;
+  }
+
+  private _getClient(options: IFileCloudflareClientOptionsNormalized) {
+    return new S3Client({
+      region: options.region,
+      endpoint: options.endpoint,
+      forcePathStyle: options.forcePathStyle ?? true,
+      credentials: {
+        accessKeyId: options.accessKeyId,
+        secretAccessKey: options.secretAccessKey,
+      },
+    });
+  }
+
+  private _createObjectKey(filename?: string) {
+    const ext = path.extname(filename ?? '') || '.bin';
+    return `${uuidv4()}${ext}`;
+  }
+
+  private _normalizeEtag(etag?: string) {
+    return etag?.replace(/^"|"$/g, '');
+  }
+
+  private _resolveExpiresIn(expiry: IFileDirectUploadInput['expiry'], fallback: number) {
+    if (expiry === undefined) return fallback;
+    const expiresAt =
+      expiry instanceof Date
+        ? expiry.getTime()
+        : typeof expiry === 'string'
+          ? new Date(expiry).getTime()
+          : Number(expiry);
+    if (!Number.isFinite(expiresAt)) {
+      throw new TypeError(`Invalid direct upload expiry: ${String(expiry)}`);
+    }
+    const expiresIn = Math.max(1, Math.floor((expiresAt - Date.now()) / 1000));
+    return expiresIn;
+  }
+
+  private _buildPublicUrl(deliveryBaseUrl: string, objectKey: string) {
+    const base = deliveryBaseUrl.replace(/\/$/, '');
+    const key = objectKey
+      .split('/')
+      .map(segment => encodeURIComponent(segment))
+      .join('/');
+    return `${base}/${key}`;
+  }
+}

package/vona/src/suite-vendor/a-file/modules/file-cloudflare/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite-vendor/a-file/modules/file-cloudflare/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

package/vona/src/suite-vendor/a-file/modules/file-native/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "vona-module-file-native",
+  "version": "5.0.3",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "exports.\\..import"
+    ]
+  },
+  "title": "file-native",
+  "vonaModule": {
+    "dependencies": {
+      "a-file": "5.0.0"
+    }
+  }
+}

package/vona/src/suite-vendor/a-file/modules/file-native/src/.metadata/index.ts

@@ -0,0 +1,111 @@
+// eslint-disable
+/** service: begin */
+export * from '../service/fileNative.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'file-native:fileNative': never;
+    }
+
+  
+}
+declare module 'vona-module-file-native' {
+  
+        export interface ServiceFileNative {
+          /** @internal */
+          get scope(): ScopeModuleFileNative;
+        }
+
+          export interface ServiceFileNative {
+            get $beanFullName(): 'file-native.service.fileNative';
+            get $onionName(): 'file-native:fileNative';
+            
+          } 
+}
+/** service: end */
+/** service: begin */
+import type { ServiceFileNative } from '../service/fileNative.ts';
+export interface IModuleService {
+  'fileNative': ServiceFileNative;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'file-native.service.fileNative': ServiceFileNative;
+  }
+}
+/** service: end */
+/** fileProvider: begin */
+export * from '../bean/fileProvider.native.ts';
+import type { IFileProviderOptionsNative } from '../bean/fileProvider.native.ts';
+import 'vona-module-a-file';
+declare module 'vona-module-a-file' {
+  
+    export interface IFileProviderRecord {
+      'file-native:native': IFileProviderOptionsNative;
+    }
+
+  
+}
+declare module 'vona-module-file-native' {
+  
+        export interface FileProviderNative {
+          /** @internal */
+          get scope(): ScopeModuleFileNative;
+        }
+
+          export interface FileProviderNative {
+            get $beanFullName(): 'file-native.fileProvider.native';
+            get $onionName(): 'file-native:native';
+            get $onionOptions(): IFileProviderOptionsNative;
+          } 
+}
+/** fileProvider: end */
+/** fileProvider: begin */
+import type { FileProviderNative } from '../bean/fileProvider.native.ts';
+export interface IModuleFileProvider {
+  'native': FileProviderNative;
+}
+/** fileProvider: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleFileNative extends BeanScopeBase {}
+
+export interface ScopeModuleFileNative {
+  util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
+service: IModuleService;
+fileProvider: IModuleFileProvider;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'file-native': ScopeModuleFileNative;
+  }
+
+  export interface IBeanScopeContainer {
+    fileNative: ScopeModuleFileNative;
+  }
+  
+  export interface IBeanScopeConfig {
+    'file-native': ReturnType<typeof config>;
+  }
+
+  
+
+  
+}
+/** scope: end */

package/vona/src/suite-vendor/a-file/modules/file-native/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'file-native';
+export { ScopeModuleFileNative as ScopeModule } from './index.ts';

package/vona/src/suite-vendor/a-file/modules/file-native/src/bean/fileProvider.native.ts

@@ -0,0 +1,125 @@
+import type {
+  EntityFile,
+  IDecoratorFileProviderOptions,
+  IFileDeliveryOptions,
+  IFileDownloadResult,
+  IFileProviderClientOptions,
+  IFileProviderClientRecord,
+  IFileProviderExecute,
+  IFileProviderResource,
+  IFileUploadInput,
+} from 'vona-module-a-file';
+
+import fse from 'fs-extra';
+import { BeanBase } from 'vona';
+import { FileProvider } from 'vona-module-a-file';
+
+export interface IFileProviderNativeClientRecord extends IFileProviderClientRecord {}
+
+export interface IFileProviderNativeClientOptions extends IFileProviderClientOptions {
+  subdir?: string;
+}
+
+export interface IFileProviderOptionsNative extends IDecoratorFileProviderOptions<
+  IFileProviderNativeClientRecord,
+  IFileProviderNativeClientOptions
+> {}
+
+@FileProvider<IFileProviderOptionsNative>({
+  base: {
+    subdir: 'default',
+    signedDeliveryKind: 'proxy',
+    public: false,
+  },
+})
+export class FileProviderNative
+  extends BeanBase
+  implements IFileProviderExecute<IFileProviderNativeClientOptions, IFileProviderOptionsNative>
+{
+  async upload(
+    input: IFileUploadInput,
+    clientOptions: IFileProviderNativeClientOptions,
+    _options: IFileProviderOptionsNative,
+  ): Promise<IFileProviderResource> {
+    const resource = await this.scope.service.fileNative.upload(input, clientOptions);
+    return {
+      ...resource,
+      filename: input.filename,
+      contentType: input.contentType,
+      meta: input.meta,
+    };
+  }
+
+  async get(
+    file: EntityFile,
+    clientOptions: IFileProviderNativeClientOptions,
+    _options: IFileProviderOptionsNative,
+  ) {
+    return {
+      resourceId: file.resourceId,
+      bucket: file.bucket,
+      objectKey: file.objectKey,
+      filename: file.filename,
+      contentType: file.contentType,
+      size: file.size,
+      etag: file.etag,
+      public: file.public ?? clientOptions.public,
+      meta: file.meta,
+      storagePath: file.storagePath,
+      deliveryBaseUrl: file.deliveryBaseUrl ?? clientOptions.deliveryBaseUrl,
+    };
+  }
+
+  async delete(
+    file: EntityFile,
+    _clientOptions: IFileProviderNativeClientOptions,
+    _options: IFileProviderOptionsNative,
+  ) {
+    await this.scope.service.fileNative.remove(file);
+  }
+
+  async getDownloadUrl(
+    file: EntityFile,
+    clientOptions: IFileProviderNativeClientOptions,
+    _options: IFileProviderOptionsNative,
+    deliveryOptions?: IFileDeliveryOptions,
+  ) {
+    return await this.scope.service.fileNative.getDownloadUrl(
+      file,
+      {
+        ...clientOptions,
+        subdir: clientOptions.subdir ?? 'default',
+        deliveryBaseUrl: file.deliveryBaseUrl ?? clientOptions.deliveryBaseUrl,
+        public: file.public ?? clientOptions.public,
+      },
+      deliveryOptions,
+    );
+  }
+
+  async download(
+    file: EntityFile,
+    clientOptions: IFileProviderNativeClientOptions,
+    options: IFileProviderOptionsNative,
+    deliveryOptions?: IFileDeliveryOptions,
+  ): Promise<IFileDownloadResult> {
+    if ((deliveryOptions?.responseMode ?? 'auto') !== 'url' && !deliveryOptions?.signed) {
+      const buffer = file.storagePath ? await fse.readFile(file.storagePath) : undefined;
+      if (buffer) {
+        return {
+          kind: 'buffer',
+          buffer,
+          filename: file.filename,
+          contentType: file.contentType,
+          signed: false,
+        };
+      }
+    }
+    return {
+      kind: 'url',
+      url: await this.getDownloadUrl(file, clientOptions, options, deliveryOptions),
+      filename: file.filename,
+      contentType: file.contentType,
+      signed: !!deliveryOptions?.signed,
+    };
+  }
+}

package/vona/src/suite-vendor/a-file/modules/file-native/src/config/config.ts

@@ -0,0 +1,7 @@
+import type { VonaApplication } from 'vona';
+
+export function config(_app: VonaApplication) {
+  return {
+    fileNative: {},
+  };
+}

package/vona/src/suite-vendor/a-file/modules/file-native/src/index.ts

@@ -0,0 +1 @@
+export * from './.metadata/index.ts';

package/vona/src/suite-vendor/a-file/modules/file-native/src/service/fileNative.ts

@@ -0,0 +1,125 @@
+import type {
+  EntityFile,
+  IFileDeliveryOptions,
+  IFileProviderResource,
+  IFileUploadInput,
+} from 'vona-module-a-file';
+
+import fse from 'fs-extra';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { BeanBase, getRuntimePathPhysicalRoot, uuidv4 } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { IFileProviderNativeClientOptions } from '../bean/fileProvider.native.ts';
+
+type IFileNativeStoredFile = Pick<
+  EntityFile,
+  'id' | 'resourceId' | 'filename' | 'storagePath' | 'public' | 'objectKey' | 'deliveryBaseUrl'
+>;
+
+@Service()
+export class ServiceFileNative extends BeanBase {
+  async upload(
+    input: IFileUploadInput,
+    options: IFileProviderNativeClientOptions,
+  ): Promise<IFileProviderResource> {
+    const resourceId = uuidv4();
+    const objectKey = this._getObjectKey(resourceId, input, options);
+    const targetPath = await this._getTargetPath(
+      objectKey,
+      input.public ?? options.public,
+      options,
+    );
+    await fse.ensureDir(path.dirname(targetPath));
+    await fse.copy(input.file, targetPath);
+    const stat = await fse.stat(targetPath);
+    return {
+      resourceId,
+      objectKey,
+      size: Number(stat.size),
+      etag: await this._calculateEtag(targetPath),
+      storagePath: targetPath,
+      deliveryBaseUrl: options.deliveryBaseUrl,
+      public: input.public ?? options.public,
+    };
+  }
+
+  async remove(file: IFileNativeStoredFile) {
+    if (!file.storagePath) return;
+    if (!(await fse.pathExists(file.storagePath))) return;
+    await fse.remove(file.storagePath);
+  }
+
+  async getDownloadUrl(
+    file: IFileNativeStoredFile,
+    options: IFileProviderNativeClientOptions,
+    _deliveryOptions?: IFileDeliveryOptions,
+  ) {
+    if (!file.storagePath) {
+      throw new Error(`File storage path missing: ${file.resourceId}`);
+    }
+    if (!(file.public ?? options.public)) {
+      const routePath = this.scope.util.combineApiPath(
+        `file/download/${file.id ?? file.resourceId}`,
+        false,
+        true,
+      );
+      return this.app.util.getAbsoluteUrlByApiPath(routePath);
+    }
+    return await this._buildUrl(file.storagePath, options.deliveryBaseUrl);
+  }
+
+  private async _getTargetPath(
+    objectKey: string,
+    isPublic: boolean | undefined,
+    options: IFileProviderNativeClientOptions,
+  ) {
+    if (isPublic) {
+      const publicPath = await this.app.util.getPublicPathPhysical(
+        path.join('file-native', options.subdir ?? 'default'),
+        true,
+      );
+      return path.join(publicPath, objectKey);
+    }
+    const runtimeRoot = getRuntimePathPhysicalRoot(this.app);
+    const basePath = path.join(
+      runtimeRoot,
+      this.ctx.instance.id.toString(),
+      'file-native',
+      options.subdir ?? 'default',
+    );
+    await fse.ensureDir(basePath);
+    return path.join(basePath, objectKey);
+  }
+
+  private _getObjectKey(
+    resourceId: string,
+    input: IFileUploadInput,
+    options: IFileProviderNativeClientOptions,
+  ) {
+    if (input.objectKey) return input.objectKey.replace(/^\/+/, '');
+    const ext = path.extname(input.filename ?? '') || path.extname(input.file) || '.bin';
+    const prefix = options.subdir ? `${options.subdir.replace(/\/+$/, '')}/` : '';
+    return `${prefix}${resourceId}${ext}`;
+  }
+
+  private async _buildUrl(targetPath: string, deliveryBaseUrl?: string) {
+    const staticPath = await this._getStaticPath(targetPath);
+    if (deliveryBaseUrl) {
+      return `${deliveryBaseUrl.replace(/\/$/, '')}/${staticPath}`;
+    }
+    return this.app.util.combineStaticPath(`/${staticPath}`);
+  }
+
+  private async _getStaticPath(targetPath: string) {
+    const publicRoot = await this.app.util.getPublicPathPhysical(undefined, true);
+    const relativePath = path.relative(publicRoot, targetPath).split(path.sep).join(path.posix.sep);
+    return path.posix.join('public', this.ctx.instance.id.toString(), relativePath);
+  }
+
+  private async _calculateEtag(targetPath: string) {
+    const buffer = await fse.readFile(targetPath);
+    return createHash('md5').update(buffer).digest('hex');
+  }
+}