cabloy 5.1.97 → 5.1.98

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

@@ -0,0 +1,322 @@
+import type { TableIdentity } from 'table-identity';
+
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import type { EntityFile } from '../entity/file.ts';
+import type {
+  IFileDeliveryOptions,
+  IFileDirectUploadInput,
+  IFileDirectUploadResult,
+  IFileProviderDirectUploadResource,
+  IFileProviderResource,
+  IFileResource,
+  IFileUploadContextResolved,
+  IFileUploadInput,
+  IFileUploadOptions,
+  IFileUploadUrlInput,
+} from '../types/file.ts';
+import type {
+  IFileProviderRecord,
+  TypeFileProviderClientOptionsByName,
+  TypeFileProviderExecuteByName,
+  TypeFileProviderOptionsByName,
+} from '../types/fileProvider.ts';
+
+interface IFileProviderContext<N extends keyof IFileProviderRecord = keyof IFileProviderRecord> {
+  beanFileProvider: TypeFileProviderExecuteByName<N>;
+  clientOptions: TypeFileProviderClientOptionsByName<N>;
+  onionOptions: TypeFileProviderOptionsByName<N>;
+}
+
+@Bean()
+export class BeanFile extends BeanBase {
+  async upload<N extends keyof IFileProviderRecord>(
+    providerName: N,
+    input: IFileUploadInput,
+    options?: IFileUploadOptions<TypeFileProviderClientOptionsByName<N>>,
+  ): Promise<IFileResource> {
+    const providerContext = await this._getProviderContextByInput(providerName, options);
+    const fileProviderResource = await providerContext.beanFileProvider.upload(
+      { ...input, public: options?.public ?? input.public, meta: options?.meta ?? input.meta },
+      providerContext.clientOptions,
+      providerContext.onionOptions,
+    );
+    const file = await this._insertFile(
+      providerName,
+      providerContext.clientName,
+      fileProviderResource,
+      {
+        fileScene: options?.fileScene,
+        public: options?.public ?? input.public,
+      },
+    );
+    return this._combineFileResource(file, fileProviderResource);
+  }
+
+  async uploadUrl<N extends keyof IFileProviderRecord>(
+    providerName: N,
+    input: IFileUploadUrlInput,
+    options?: IFileUploadOptions<TypeFileProviderClientOptionsByName<N>>,
+  ): Promise<IFileResource> {
+    const providerContext = await this._getProviderContextByInput(providerName, options);
+    if (!providerContext.beanFileProvider.uploadUrl) {
+      throw new Error(`File provider does not support uploadUrl: ${String(providerName)}`);
+    }
+    const fileProviderResource = await providerContext.beanFileProvider.uploadUrl(
+      { ...input, public: options?.public ?? input.public, meta: options?.meta ?? input.meta },
+      providerContext.clientOptions,
+      providerContext.onionOptions,
+    );
+    const file = await this._insertFile(
+      providerName,
+      providerContext.clientName,
+      fileProviderResource,
+      {
+        fileScene: options?.fileScene,
+        public: options?.public ?? input.public,
+      },
+    );
+    return this._combineFileResource(file, fileProviderResource);
+  }
+
+  async createDirectUpload<N extends keyof IFileProviderRecord>(
+    providerName: N,
+    input: IFileDirectUploadInput,
+    options?: IFileUploadOptions<TypeFileProviderClientOptionsByName<N>>,
+  ): Promise<IFileDirectUploadResult> {
+    const providerContext = await this._getProviderContextByInput(providerName, options);
+    if (!providerContext.beanFileProvider.createDirectUpload) {
+      throw new Error(`File provider does not support createDirectUpload: ${String(providerName)}`);
+    }
+    const fileProviderResource = await providerContext.beanFileProvider.createDirectUpload(
+      { ...input, public: options?.public ?? input.public, meta: options?.meta ?? input.meta },
+      providerContext.clientOptions,
+      providerContext.onionOptions,
+    );
+    const file = await this._insertFile(
+      providerName,
+      providerContext.clientName,
+      fileProviderResource,
+      {
+        fileScene: options?.fileScene,
+        public: options?.public ?? input.public,
+      },
+    );
+    return {
+      ...this._combineFileResource(file, fileProviderResource),
+      uploadUrl: fileProviderResource.uploadUrl,
+      headers: fileProviderResource.headers,
+      method: fileProviderResource.method,
+    };
+  }
+
+  async get(fileId: TableIdentity): Promise<IFileResource | undefined> {
+    const file = await this.scope.model.file.getById(fileId);
+    if (!file) return;
+    const fileProviderResource = await this._getFileProviderResource(file);
+    return this._combineFileResource(file, fileProviderResource);
+  }
+
+  async delete(fileId: TableIdentity) {
+    const file = await this.scope.model.file.getById(fileId);
+    if (!file) return;
+    const { beanFileProvider, clientOptions, onionOptions } = await this._getProviderContext(file);
+    await beanFileProvider.delete(file, clientOptions, onionOptions);
+    await this.scope.model.file.deleteById(file.id);
+  }
+
+  async getDownloadUrl(fileId: TableIdentity, deliveryOptions?: IFileDeliveryOptions) {
+    const file = await this.scope.model.file.getById(fileId);
+    if (!file) throw new Error(`not found file: ${fileId}`);
+    const deliveryOptionsResolved = this._mergeDeliveryOptions(file, deliveryOptions);
+    const { beanFileProvider, clientOptions, onionOptions } = await this._getProviderContext(file);
+    if (
+      deliveryOptionsResolved.signed &&
+      (clientOptions.signedDeliveryKind ?? 'proxy') === 'proxy'
+    ) {
+      return await this._createSignedDownloadUrl(file.id, deliveryOptionsResolved);
+    }
+    return await beanFileProvider.getDownloadUrl(
+      file,
+      clientOptions,
+      onionOptions,
+      deliveryOptionsResolved,
+    );
+  }
+
+  async download(fileId: TableIdentity, deliveryOptions?: IFileDeliveryOptions) {
+    const file = await this.scope.model.file.getById(fileId);
+    if (!file) throw new Error(`not found file: ${fileId}`);
+    const deliveryOptionsResolved = this._mergeDeliveryOptions(file, deliveryOptions);
+    const { beanFileProvider, clientOptions, onionOptions } = await this._getProviderContext(file);
+    if (
+      deliveryOptionsResolved.signed &&
+      (clientOptions.signedDeliveryKind ?? 'proxy') === 'proxy'
+    ) {
+      return {
+        kind: 'url' as const,
+        url: await this._createSignedDownloadUrl(file.id, deliveryOptionsResolved),
+        filename: file.filename,
+        contentType: file.contentType,
+        signed: true,
+      };
+    }
+    if (beanFileProvider.download) {
+      return await beanFileProvider.download(
+        file,
+        clientOptions,
+        onionOptions,
+        deliveryOptionsResolved,
+      );
+    }
+    return {
+      kind: 'url' as const,
+      url: await beanFileProvider.getDownloadUrl(
+        file,
+        clientOptions,
+        onionOptions,
+        deliveryOptionsResolved,
+      ),
+      filename: file.filename,
+      contentType: file.contentType,
+      signed: !!deliveryOptionsResolved.signed,
+    };
+  }
+
+  private async _getFileProviderResource(file: EntityFile) {
+    const { beanFileProvider, clientOptions, onionOptions } = await this._getProviderContext(file);
+    return await beanFileProvider.get(file, clientOptions, onionOptions);
+  }
+
+  private async _getProviderContext<N extends keyof IFileProviderRecord>(
+    file: EntityFile & { providerName: N },
+  ): Promise<IFileProviderContext<N>> {
+    const providerContext = await this.bean.fileProvider.getClientOptions({
+      providerName: file.providerName,
+      clientName: file.clientName,
+    });
+    if (!providerContext.entityFileProvider) {
+      throw new Error(`File provider not found: ${String(file.providerName)}.${file.clientName}`);
+    }
+    return {
+      beanFileProvider: this._getBeanFileProvider(file.providerName, providerContext.beanFullName),
+      clientOptions: this._normalizeOptions(providerContext.clientOptions),
+      onionOptions: this._normalizeOptions(providerContext.onionOptions),
+    };
+  }
+
+  private async _getProviderContextByInput<N extends keyof IFileProviderRecord>(
+    providerName: N,
+    options?: IFileUploadOptions<TypeFileProviderClientOptionsByName<N>>,
+  ): Promise<IFileProviderContext<N> & { clientName: string }> {
+    const clientName = options?.clientName ?? 'default';
+    const providerContext = await this.bean.fileProvider.getClientOptions(
+      {
+        providerName,
+        clientName,
+      },
+      options?.clientOptions,
+    );
+    if (!providerContext.entityFileProvider || providerContext.disabled) {
+      return this.app.throw(403);
+    }
+    return {
+      clientName,
+      beanFileProvider: this._getBeanFileProvider(providerName, providerContext.beanFullName),
+      clientOptions: this._normalizeOptions(providerContext.clientOptions),
+      onionOptions: this._normalizeOptions(providerContext.onionOptions),
+    };
+  }
+
+  private _getBeanFileProvider<N extends keyof IFileProviderRecord>(
+    _providerName: N,
+    beanFullName: string,
+  ): TypeFileProviderExecuteByName<N> {
+    return this.app.bean._getBean<TypeFileProviderExecuteByName<N>>(beanFullName as never);
+  }
+
+  private _normalizeOptions<T extends object>(options: T | undefined): T {
+    return (options ?? {}) as T;
+  }
+
+  private _mergeDeliveryOptions(
+    file: Pick<IFileResource, 'public'>,
+    deliveryOptions?: IFileDeliveryOptions,
+  ): IFileDeliveryOptions {
+    const signed = deliveryOptions?.signed ?? !file.public;
+    const expiresIn = deliveryOptions?.expiresIn;
+    const expiresAt = deliveryOptions?.expiresAt;
+    const responseMode = deliveryOptions?.responseMode;
+    return {
+      signed,
+      expiresIn,
+      expiresAt,
+      responseMode,
+    };
+  }
+
+  private async _createSignedDownloadUrl(
+    fileId: TableIdentity,
+    deliveryOptions: IFileDeliveryOptions,
+  ) {
+    const routePath = this.scope.util.combineApiPath(`file/download/${fileId}`, false, true);
+    const tokenPayload = await this.bean.fileUploadPolicy.createDownloadToken({
+      fileId,
+      expiresIn: deliveryOptions.expiresIn,
+    });
+    const routeUrl = this.app.util.getAbsoluteUrlByApiPath(routePath);
+    const url = new URL(routeUrl);
+    url.searchParams.set('token', tokenPayload.token);
+    return url.toString();
+  }
+
+  private async _insertFile(
+    providerName: keyof IFileProviderRecord,
+    clientName: string,
+    fileProviderResource: IFileProviderResource | IFileProviderDirectUploadResource,
+    context?: Partial<IFileUploadContextResolved>,
+  ) {
+    return await this.scope.model.file.insert({
+      providerName,
+      clientName,
+      resourceId: fileProviderResource.resourceId,
+      bucket: fileProviderResource.bucket,
+      objectKey: fileProviderResource.objectKey,
+      filename: fileProviderResource.filename,
+      contentType: fileProviderResource.contentType,
+      size: fileProviderResource.size,
+      etag: fileProviderResource.etag,
+      public: fileProviderResource.public ?? context?.public,
+      meta: fileProviderResource.meta,
+      storagePath: fileProviderResource.storagePath,
+      deliveryBaseUrl: fileProviderResource.deliveryBaseUrl,
+      fileScene: context?.fileScene,
+    });
+  }
+
+  private _combineFileResource(
+    file: EntityFile,
+    fileProviderResource?: IFileProviderResource,
+  ): IFileResource {
+    return {
+      id: file.id,
+      provider: file.providerName,
+      clientName: file.clientName,
+      fileScene: file.fileScene,
+      resourceId: fileProviderResource?.resourceId ?? file.resourceId,
+      bucket: fileProviderResource?.bucket ?? file.bucket,
+      objectKey: fileProviderResource?.objectKey ?? file.objectKey,
+      filename: fileProviderResource?.filename ?? file.filename,
+      contentType: fileProviderResource?.contentType ?? file.contentType,
+      size: fileProviderResource?.size ?? file.size,
+      etag: fileProviderResource?.etag ?? file.etag,
+      public: fileProviderResource?.public ?? file.public,
+      meta: fileProviderResource?.meta ?? file.meta,
+      storagePath: fileProviderResource?.storagePath ?? file.storagePath,
+      deliveryBaseUrl: fileProviderResource?.deliveryBaseUrl ?? file.deliveryBaseUrl,
+      raw: fileProviderResource?.raw,
+      uploadedAt: file.createdAt,
+    };
+  }
+}

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

@@ -0,0 +1,62 @@
+import { BeanBase, deepExtend } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import type { EntityFileProvider } from '../entity/fileProvider.ts';
+import type {
+  IFileProviderRecord,
+  TypeFileProviderClientOptionsByName,
+  TypeFileProviderOptionsByName,
+  TypeFileProviderPick,
+} from '../types/fileProvider.ts';
+
+@Bean()
+export class BeanFileProvider extends BeanBase {
+  async get(data: TypeFileProviderPick) {
+    if (!data.id && !data.clientName) data = { ...data, clientName: 'default' };
+    const res = await this.scope.model.fileProvider.get(data);
+    if (res) return res;
+    if (data.id) throw new Error(`not found file provider: ${data.id}`);
+    if (!data.providerName) throw new Error('Invalid file provider');
+    return await this.scope.redlock.lockIsolate('fileProvider.register', async () => {
+      return await this._registerFileProviderLock(data);
+    });
+  }
+
+  private async _registerFileProviderLock(data: TypeFileProviderPick) {
+    const res = await this.scope.model.fileProvider.get(data, { cache: { force: true } });
+    if (res) return res;
+    const dataNew: Partial<EntityFileProvider> = {
+      disabled: false,
+      providerName: data.providerName,
+      clientName: data.clientName,
+      clientOptions: undefined,
+    };
+    return await this.scope.model.fileProvider.insert(dataNew);
+  }
+
+  async getClientOptions<N extends keyof IFileProviderRecord>(
+    data: TypeFileProviderPick & { providerName: N },
+    clientOptionsCustom?: TypeFileProviderClientOptionsByName<N>,
+    clientOptionsDefault?: TypeFileProviderClientOptionsByName<N>,
+  ) {
+    const entityFileProvider = await this.bean.fileProvider.get(data);
+    if (!entityFileProvider) return { entityFileProvider: undefined };
+    const disabled = entityFileProvider.disabled;
+    const fileProviderName = entityFileProvider.providerName as N;
+    const clientName = entityFileProvider.clientName ?? 'default';
+    const onionSlice = this.bean.onion.fileProvider.getOnionSliceEnabled(true, fileProviderName);
+    if (!onionSlice) throw new Error(`File provider not found: ${fileProviderName}`);
+    const beanFullName = onionSlice.beanOptions.beanFullName as N;
+    const onionOptions =
+      (onionSlice.beanOptions.options as TypeFileProviderOptionsByName<N> | undefined) ??
+      ({} as TypeFileProviderOptionsByName<N>);
+    const clientOptions = deepExtend(
+      (clientOptionsDefault ?? {}) as TypeFileProviderClientOptionsByName<N>,
+      onionOptions.base,
+      onionOptions.clients?.[clientName as keyof typeof onionOptions.clients],
+      entityFileProvider.clientOptions as TypeFileProviderClientOptionsByName<N> | undefined,
+      clientOptionsCustom,
+    ) as TypeFileProviderClientOptionsByName<N>;
+    return { entityFileProvider, disabled, beanFullName, onionOptions, clientOptions };
+  }
+}

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

@@ -0,0 +1,196 @@
+import fse from 'fs-extra';
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import type {
+  IFileDownloadTokenPayload,
+  IFileUploadContextResolved,
+  IFileUploadPolicyResolved,
+  IFileUploadTokenPayload,
+} from '../types/file.ts';
+import type {
+  IDecoratorFileSceneOptions,
+  IDecoratorFileSceneOptionsProvider,
+  IFileSceneRecord,
+} from '../types/fileScene.ts';
+
+import { getFileExtension, matchesFileMimeType } from '../lib/fileUploadValidation.ts';
+
+@Bean()
+export class BeanFileUploadPolicy extends BeanBase {
+  async createUploadToken(data: {
+    fileScene: keyof IFileSceneRecord;
+    size: number;
+    mimeType: string;
+    expiresIn?: number;
+  }) {
+    const payload = await this.resolveUploadPolicy(data);
+    const path = this.scope.util.combineApiPath('file/upload', false, true);
+    const token = await this.bean.jwt.createTempAuthToken(
+      {
+        kind: 'fileUpload',
+        ...payload,
+      } as IFileUploadTokenPayload,
+      {
+        path,
+        expiresIn: data.expiresIn,
+      },
+    );
+    return { token, expiresIn: data.expiresIn };
+  }
+
+  async createDownloadToken(data: { fileId: number | string; expiresIn?: number }) {
+    const path = this.scope.util.combineApiPath(`file/download/${data.fileId}`, false, true);
+    const token = await this.bean.jwt.createTempAuthToken(
+      {
+        kind: 'fileDownload',
+        fileId: data.fileId,
+      } as IFileDownloadTokenPayload,
+      {
+        path,
+        expiresIn: data.expiresIn,
+      },
+    );
+    return { token, expiresIn: data.expiresIn };
+  }
+
+  async verifyUploadToken(token: string | undefined, routePathRaw: string) {
+    const payload = (await this.bean.jwt.get('access').verify(token, {
+      path: routePathRaw,
+    })) as IFileUploadTokenPayload | undefined;
+    if (!payload || payload.kind !== 'fileUpload') {
+      return this.app.throw(401);
+    }
+    return payload;
+  }
+
+  async verifyDownloadToken(token: string | undefined, routePathRaw: string) {
+    const payload = (await this.bean.jwt.get('access').verify(token, {
+      path: routePathRaw,
+    })) as IFileDownloadTokenPayload | undefined;
+    if (!payload || payload.kind !== 'fileDownload') {
+      return this.app.throw(401);
+    }
+    return payload;
+  }
+
+  async validateUploadFile(
+    file: {
+      file: string;
+      filename?: string;
+      mimeType: string;
+    },
+    payload: IFileUploadTokenPayload,
+  ) {
+    const stat = await fse.stat(file.file);
+    const fileSize = Number(stat.size);
+    if (fileSize !== payload.fileSize) {
+      return this.app.throw(403, `file size mismatch: size=${fileSize}`);
+    }
+    if (payload.maxSize && fileSize > payload.maxSize) {
+      return this.app.throw(403, `file too large: maxSize=${payload.maxSize}`);
+    }
+    const mimeType = file.mimeType.toLowerCase();
+    if (mimeType !== payload.mimeType) {
+      return this.app.throw(403, `file mimeType mismatch: mimeType=${mimeType}`);
+    }
+    if (payload.mimeTypes?.length && !matchesFileMimeType(mimeType, payload.mimeTypes)) {
+      return this.app.throw(403, `unsupported file mimeType: ${mimeType}`);
+    }
+    const extension = getFileExtension(file.filename);
+    if (payload.extensions?.length && extension && !payload.extensions.includes(extension)) {
+      return this.app.throw(403, `unsupported file extension: ${extension}`);
+    }
+  }
+
+  async resolveUploadContext(data: {
+    fileScene: keyof IFileSceneRecord;
+  }): Promise<IFileUploadContextResolved> {
+    const fileScene = data.fileScene;
+    const sceneOptions = this._getSceneOptions(fileScene);
+    const { providerName, clientName } = await this._resolveProvider(sceneOptions);
+    const providerContext = await this.bean.fileProvider.getClientOptions({
+      providerName,
+      clientName,
+    });
+    if (!providerContext.entityFileProvider || providerContext.disabled) {
+      return this.app.throw(403, `File provider unavailable: ${providerName}.${clientName}`);
+    }
+    return {
+      fileScene,
+      providerName,
+      clientName,
+      public: this._resolvePublic(providerContext.clientOptions, sceneOptions),
+      meta: await this._resolveSceneMeta(sceneOptions),
+    };
+  }
+
+  async resolveUploadPolicy(data: {
+    fileScene: keyof IFileSceneRecord;
+    size: number;
+    mimeType: string;
+  }): Promise<IFileUploadPolicyResolved> {
+    const fileConfig = this.scope.config.file;
+    const context = await this.resolveUploadContext({ fileScene: data.fileScene });
+    const sceneOptions = this._getSceneOptions(context.fileScene);
+    const uploadOptions = {
+      ...(fileConfig.upload ?? {}),
+      ...(sceneOptions.upload ?? {}),
+    };
+    const maxSize = uploadOptions.maxSize;
+    const mimeTypes = [...(uploadOptions.mimeTypes ?? [])];
+    const extensions = [...(uploadOptions.extensions ?? [])];
+    const mimeType = data.mimeType.toLowerCase();
+    if (maxSize && data.size > maxSize) {
+      return this.app.throw(403, `file too large: maxSize=${maxSize}`);
+    }
+    if (mimeTypes.length > 0 && !matchesFileMimeType(mimeType, mimeTypes)) {
+      return this.app.throw(403, `unsupported file mimeType: ${mimeType}`);
+    }
+    return {
+      ...context,
+      maxSize,
+      mimeTypes: mimeTypes.length > 0 ? mimeTypes : undefined,
+      extensions: extensions.length > 0 ? extensions : undefined,
+      multiple: uploadOptions.multiple,
+      fileSize: data.size,
+      mimeType,
+    };
+  }
+
+  private _getSceneOptions(fileScene: keyof IFileSceneRecord): IDecoratorFileSceneOptions {
+    const onionSlice = this.bean.onion.fileScene.getOnionSlice(fileScene);
+    if (!onionSlice) throw new Error(`not found file scene: ${fileScene}`);
+    return onionSlice.beanOptions.options ?? {};
+  }
+
+  private async _resolveProvider(
+    sceneOptions: IDecoratorFileSceneOptions,
+  ): Promise<Required<IDecoratorFileSceneOptionsProvider>> {
+    const provider =
+      typeof sceneOptions.provider === 'function'
+        ? await sceneOptions.provider(this.ctx)
+        : sceneOptions.provider;
+    const providerName = provider?.providerName ?? this.scope.config.file.defaultProvider;
+    const clientName = provider?.clientName ?? this.scope.config.file.defaultClientName;
+    return { providerName, clientName };
+  }
+
+  private async _resolveSceneMeta(sceneOptions: IDecoratorFileSceneOptions) {
+    const meta = sceneOptions.meta;
+    if (!meta) return undefined;
+    if (typeof meta === 'function') {
+      return await meta(this.ctx);
+    }
+    return meta;
+  }
+
+  private _resolvePublic(
+    clientOptions: { public?: boolean } | undefined,
+    sceneOptions: IDecoratorFileSceneOptions,
+  ) {
+    return (
+      sceneOptions.upload?.public ?? clientOptions?.public ?? this.scope.config.file.public ?? false
+    );
+  }
+}

package/vona/src/suite-vendor/a-file/modules/a-file/src/bean/meta.redlock.ts

@@ -0,0 +1,11 @@
+import { Meta } from 'vona-module-a-meta';
+import { BeanRedlockBase } from 'vona-module-a-redlock';
+
+export type TypeRedlockLockResource = never;
+export type TypeRedlockLockIsolateResource = 'fileProvider.register';
+
+@Meta()
+export class MetaRedlock extends BeanRedlockBase<
+  TypeRedlockLockResource,
+  TypeRedlockLockIsolateResource
+> {}

package/vona/src/suite-vendor/a-file/modules/a-file/src/bean/meta.version.ts

@@ -0,0 +1,38 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version === 1) {
+      const entityFileProvider = this.scope.entity.fileProvider;
+      await this.bean.model.createTable(entityFileProvider.$table, table => {
+        table.basicFieldsSimple();
+        table.boolean(entityFileProvider.disabled).defaultTo(false);
+        table.string(entityFileProvider.providerName, 255);
+        table.string(entityFileProvider.clientName, 255);
+        table.json(entityFileProvider.clientOptions);
+      });
+      const entityFile = this.scope.entity.file;
+      await this.bean.model.createTable(entityFile.$table, table => {
+        table.basicFields();
+        table.string(entityFile.providerName, 255);
+        table.string(entityFile.clientName, 255);
+        table.string(entityFile.resourceId, 255);
+        table.string(entityFile.bucket, 255);
+        table.text(entityFile.objectKey);
+        table.string(entityFile.filename, 255);
+        table.string(entityFile.contentType, 255);
+        table.integer(entityFile.size);
+        table.string(entityFile.etag, 255);
+        table.boolean(entityFile.public).defaultTo(false);
+        table.json(entityFile.meta);
+        table.text(entityFile.storagePath);
+        table.text(entityFile.deliveryBaseUrl);
+        table.string(entityFile.fileScene, 255);
+      });
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import type { VonaApplication } from 'vona';
+
+import type { IFileProviderRecord } from '../types/fileProvider.ts';
+
+export function config(_app: VonaApplication) {
+  return {
+    file: {
+      defaultProvider: 'file-native:native' as keyof IFileProviderRecord,
+      defaultClientName: 'default',
+      public: false,
+      upload: {
+        maxSize: 20 * 1024 * 1024,
+      },
+    },
+  };
+}

package/vona/src/suite-vendor/a-file/modules/a-file/src/config/locale/en-us.ts

@@ -0,0 +1 @@
+export default {};

package/vona/src/suite-vendor/a-file/modules/a-file/src/config/locale/zh-cn.ts

@@ -0,0 +1 @@
+export default {};