cabloy 5.1.95 → 5.1.97

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

@@ -0,0 +1,40 @@
+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) {
+      // aImageProvider
+      const entityImageProvider = this.scope.entity.imageProvider;
+      await this.bean.model.createTable(entityImageProvider.$table, table => {
+        table.basicFieldsSimple();
+        table.boolean(entityImageProvider.disabled).defaultTo(false);
+        table.string(entityImageProvider.providerName, 255);
+        table.string(entityImageProvider.clientName, 255);
+        table.json(entityImageProvider.clientOptions);
+      });
+      // aImage
+      const entityImage = this.scope.entity.image;
+      await this.bean.model.createTable(entityImage.$table, table => {
+        table.basicFields();
+        table.string(entityImage.providerName, 255);
+        table.string(entityImage.clientName, 255);
+        table.string(entityImage.resourceId, 255);
+        table.string(entityImage.filename, 255);
+        table.string(entityImage.contentType, 255);
+        table.integer(entityImage.size);
+        table.integer(entityImage.width);
+        table.integer(entityImage.height);
+        table.boolean(entityImage.requireSignedURLs).defaultTo(false);
+        table.json(entityImage.variants);
+        table.json(entityImage.meta);
+        table.text(entityImage.storagePath);
+        table.text(entityImage.deliveryBaseUrl);
+        table.string(entityImage.imageScene, 255);
+      });
+    }
+  }
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/bean/serializerTransform.resolveView.ts

@@ -0,0 +1,44 @@
+import type {
+  IDecoratorSerializerTransformOptions,
+  ISerializerTransform,
+} from 'vona-module-a-serialization';
+
+import { BeanBase } from 'vona';
+import { SerializerTransform } from 'vona-module-a-serialization';
+
+import type { DtoImageView } from '../dto/imageView.ts';
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+export type TypeSerializerTransformResolveViewValue = unknown;
+
+export type TypeSerializerTransformResolveViewData = object;
+
+export type TypeSerializerTransformResolveViewResult = DtoImageView | undefined;
+
+export interface ISerializerTransformOptionsResolveView extends IDecoratorSerializerTransformOptions {
+  fieldName: string;
+  imageScene?: keyof IImageSceneRecord;
+}
+
+@SerializerTransform<ISerializerTransformOptionsResolveView>()
+export class SerializerTransformResolveView
+  extends BeanBase
+  implements
+    ISerializerTransform<
+      TypeSerializerTransformResolveViewValue,
+      TypeSerializerTransformResolveViewData,
+      TypeSerializerTransformResolveViewResult
+    >
+{
+  async transform(
+    _value: TypeSerializerTransformResolveViewValue,
+    data: TypeSerializerTransformResolveViewData,
+    options: ISerializerTransformOptionsResolveView,
+  ): Promise<TypeSerializerTransformResolveViewResult> {
+    return await this.bean.image.resolveView(
+      data[options.fieldName],
+      undefined,
+      options.imageScene,
+    );
+  }
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/bean/serializerTransform.resolveViews.ts

@@ -0,0 +1,44 @@
+import type {
+  IDecoratorSerializerTransformOptions,
+  ISerializerTransform,
+} from 'vona-module-a-serialization';
+
+import { BeanBase } from 'vona';
+import { SerializerTransform } from 'vona-module-a-serialization';
+
+import type { DtoImageView } from '../dto/imageView.ts';
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+export type TypeSerializerTransformResolveViewsValue = unknown;
+
+export type TypeSerializerTransformResolveViewsData = object;
+
+export type TypeSerializerTransformResolveViewsResult = DtoImageView[] | undefined;
+
+export interface ISerializerTransformOptionsResolveViews extends IDecoratorSerializerTransformOptions {
+  fieldName: string;
+  imageScene?: keyof IImageSceneRecord;
+}
+
+@SerializerTransform<ISerializerTransformOptionsResolveViews>()
+export class SerializerTransformResolveViews
+  extends BeanBase
+  implements
+    ISerializerTransform<
+      TypeSerializerTransformResolveViewsValue,
+      TypeSerializerTransformResolveViewsData,
+      TypeSerializerTransformResolveViewsResult
+    >
+{
+  async transform(
+    _value: TypeSerializerTransformResolveViewsValue,
+    data: TypeSerializerTransformResolveViewsData,
+    options: ISerializerTransformOptionsResolveViews,
+  ): Promise<TypeSerializerTransformResolveViewsResult> {
+    return await this.bean.image.resolveViews(
+      data[options.fieldName],
+      undefined,
+      options.imageScene,
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+import type { VonaApplication } from 'vona';
+
+import type { IImageProviderRecord } from '../types/imageProvider.ts';
+
+export function config(_app: VonaApplication) {
+  return {
+    image: {
+      defaultVariant: 'original',
+      defaultProvider: 'image-native:native' as keyof IImageProviderRecord,
+      defaultClientName: 'default',
+      upload: {
+        maxSize: 2 * 1024 * 1024,
+        mimeTypes: ['image/png', 'image/jpeg', 'image/webp'],
+      },
+    },
+  };
+}

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

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

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

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

package/vona/src/suite-vendor/a-image/modules/a-image/src/controller/image.ts

@@ -0,0 +1,165 @@
+import type { IUploadFile } from 'vona-module-a-upload';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import fse from 'fs-extra';
+import { BeanBase } from 'vona';
+import { Core } from 'vona-module-a-core';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+
+import type { IImageUploadTokenPayload } from '../types/image.ts';
+
+import { DtoImageDeliveryRequest } from '../dto/imageDeliveryRequest.ts';
+import { DtoImageDirectUploadRequest } from '../dto/imageDirectUploadRequest.ts';
+import { DtoImageDirectUploadResponse } from '../dto/imageDirectUploadResponse.ts';
+import { DtoImageUploadResponse } from '../dto/imageUploadResponse.ts';
+import { DtoImageUploadTokenRequest } from '../dto/imageUploadTokenRequest.ts';
+import { DtoImageUploadTokenResponse } from '../dto/imageUploadTokenResponse.ts';
+import { DtoImageUploadUrlRequest } from '../dto/imageUploadUrlRequest.ts';
+
+export interface IControllerOptionsImage extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsImage>({ path: 'image' })
+export class ControllerImage extends BeanBase {
+  @Web.post('upload-token')
+  @Api.body(DtoImageUploadTokenResponse)
+  async createUploadToken(@Arg.body() data: DtoImageUploadTokenRequest) {
+    return await this.bean.imageUploadPolicy.createUploadToken(data);
+  }
+
+  @Web.post('upload')
+  @Core.fileUpload()
+  @Api.body(DtoImageUploadResponse)
+  @Api.contentType('application/json')
+  async upload(@Arg.field('token') token: string, @Arg.file('image') file: IUploadFile) {
+    const payload = await this.bean.imageUploadPolicy.verifyUploadToken(
+      token,
+      this.ctx.route.routePathRaw,
+    );
+    await this._validateUploadFile(file, payload);
+    const image = await this.bean.image.upload(
+      payload.providerName,
+      {
+        file: file.file,
+        filename: file.info.filename,
+        contentType: file.info.mimeType,
+      },
+      {
+        clientName: payload.clientName,
+        meta: payload.meta,
+        imageScene: payload.imageScene,
+      },
+    );
+    return {
+      ...image,
+      url: await this.bean.image.getVariantUrl(image.id),
+      signed: !!image.requireSignedURLs,
+    };
+  }
+
+  @Web.post('direct-upload')
+  @Api.body(DtoImageDirectUploadResponse)
+  async createDirectUpload(@Arg.body() data: DtoImageDirectUploadRequest) {
+    const policy = await this.bean.imageUploadPolicy.resolveUploadPolicy({
+      imageScene: data.imageScene,
+      size: data.size,
+      mimeType: data.mimeType,
+    });
+    return await this.bean.image.createDirectUpload(
+      policy.providerName,
+      {
+        filename: data.filename,
+        contentType: data.contentType,
+        expiry: data.expiry,
+        customId: data.customId,
+      },
+      {
+        clientName: policy.clientName,
+        meta: policy.meta,
+        imageScene: policy.imageScene,
+      },
+    );
+  }
+
+  @Web.post('upload-url')
+  @Api.body(DtoImageUploadResponse)
+  async uploadUrl(@Arg.body() data: DtoImageUploadUrlRequest) {
+    const policy = await this.bean.imageUploadPolicy.resolveUploadPolicy({
+      imageScene: data.imageScene,
+      size: data.size,
+      mimeType: data.mimeType,
+    });
+    const image = await this.bean.image.uploadUrl(
+      policy.providerName,
+      {
+        url: data.url,
+        filename: data.filename,
+        contentType: data.contentType,
+      },
+      {
+        clientName: policy.clientName,
+        meta: policy.meta,
+        imageScene: policy.imageScene,
+      },
+    );
+    return {
+      ...image,
+      url: await this.bean.image.getVariantUrl(image.id),
+      signed: !!image.requireSignedURLs,
+    };
+  }
+
+  @Web.get('delivery/:imageId')
+  async delivery(
+    @Arg.param('imageId', v.tableIdentity()) imageId: number,
+    @Arg.query(v.object(DtoImageDeliveryRequest)) query: DtoImageDeliveryRequest,
+  ) {
+    const payload = await this.bean.imageUploadPolicy.verifyDeliveryToken(
+      query.token,
+      this.ctx.route.routePathRaw,
+    );
+    if (String(payload.imageId) !== String(imageId)) {
+      return this.app.throw(401);
+    }
+    this.ctx.redirect(payload.targetUrl);
+  }
+
+  private async _validateUploadFile(file: IUploadFile, payload: IImageUploadTokenPayload) {
+    const stat = await fse.stat(file.file);
+    const fileSize = Number(stat.size);
+    if (fileSize !== payload.fileSize) {
+      return this.app.throw(403, `image size mismatch: size=${fileSize}`);
+    }
+    if (payload.maxSize && fileSize > payload.maxSize) {
+      return this.app.throw(403, `image too large: maxSize=${payload.maxSize}`);
+    }
+    const mimeType = file.info.mimeType.toLowerCase();
+    if (mimeType !== payload.mimeType) {
+      return this.app.throw(403, `image mimeType mismatch: mimeType=${mimeType}`);
+    }
+    if (payload.mimeTypes?.length && !this._matchesMimeType(mimeType, payload.mimeTypes)) {
+      return this.app.throw(403, `unsupported image mimeType: ${mimeType}`);
+    }
+    const extension = this._getExtension(file.info.filename);
+    if (payload.extensions?.length && extension && !payload.extensions.includes(extension)) {
+      return this.app.throw(403, `unsupported image extension: ${extension}`);
+    }
+  }
+
+  private _matchesMimeType(mimeType: string, mimeTypes: string[]) {
+    return mimeTypes.some(item => {
+      if (item === mimeType) return true;
+      if (item.endsWith('/*')) {
+        return mimeType.startsWith(`${item.slice(0, -1)}`);
+      }
+      return false;
+    });
+  }
+
+  private _getExtension(filename?: string) {
+    if (!filename) return '';
+    const index = filename.lastIndexOf('.');
+    if (index === -1) return '';
+    return filename.slice(index).toLowerCase();
+  }
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageDeliveryRequest.ts

@@ -0,0 +1,20 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoImageTransformOptions } from './imageTransformOptions.tsx';
+
+export interface IDtoOptionsImageDeliveryRequest extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageDeliveryRequest>()
+export class DtoImageDeliveryRequest {
+  @Api.field(v.optional())
+  variantName?: string;
+
+  @Api.field(v.optional(), v.object(DtoImageTransformOptions))
+  transformOptions?: Record<string, unknown>;
+
+  @Api.field(v.optional())
+  token?: string;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageDirectUploadRequest.ts

@@ -0,0 +1,36 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+export interface IDtoOptionsImageDirectUploadRequest extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageDirectUploadRequest>()
+export class DtoImageDirectUploadRequest {
+  @Api.field(z.string())
+  imageScene: keyof IImageSceneRecord;
+
+  @Api.field(v.optional())
+  filename?: string;
+
+  @Api.field(z.number().int().positive())
+  size: number;
+
+  @Api.field(z.string())
+  mimeType: string;
+
+  @Api.field(v.optional())
+  contentType?: string;
+
+  @Api.field(v.optional())
+  requireSignedURLs?: boolean;
+
+  @Api.field(v.optional())
+  expiry?: string;
+
+  @Api.field(v.optional())
+  customId?: string;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageDirectUploadResponse.ts

@@ -0,0 +1,38 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+import type { IImageProviderRecord } from '../types/imageProvider.ts';
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+export interface IDtoOptionsImageDirectUploadResponse extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageDirectUploadResponse>()
+export class DtoImageDirectUploadResponse {
+  @Api.field(v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(z.string())
+  provider: keyof IImageProviderRecord;
+
+  @Api.field()
+  clientName: string;
+
+  @Api.field()
+  resourceId: string;
+
+  @Api.field()
+  uploadUrl: string;
+
+  @Api.field(v.optional())
+  draft?: boolean;
+
+  @Api.field(v.optional())
+  filename?: string;
+
+  @Api.field(v.optional(), z.string())
+  imageScene?: keyof IImageSceneRecord;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageTransformOptions.tsx

@@ -0,0 +1,42 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+import type { IImageTransformOptions } from '../types/image.ts';
+
+export interface IDtoOptionsImageTransformOptions extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageTransformOptions>()
+export class DtoImageTransformOptions implements IImageTransformOptions {
+  @Api.field(v.optional())
+  width?: number;
+
+  @Api.field(v.optional())
+  height?: number;
+
+  @Api.field(v.optional(), z.enum(['scale-down', 'contain', 'cover', 'crop', 'pad']))
+  fit?: 'scale-down' | 'contain' | 'cover' | 'crop' | 'pad';
+
+  @Api.field(v.optional(), z.enum(['auto', 'center', 'top', 'bottom', 'left', 'right']))
+  gravity?: 'auto' | 'center' | 'top' | 'bottom' | 'left' | 'right';
+
+  @Api.field(v.optional())
+  background?: string;
+
+  @Api.field(v.optional())
+  quality?: number;
+
+  @Api.field(v.optional(), z.enum(['auto', 'avif', 'webp', 'jpeg', 'png']))
+  format?: 'auto' | 'avif' | 'webp' | 'jpeg' | 'png';
+
+  @Api.field(v.optional())
+  dpr?: number;
+
+  @Api.field(v.optional())
+  rotate?: number;
+
+  @Api.field(v.optional())
+  sharpen?: number;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageUploadResponse.ts

@@ -0,0 +1,62 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $schema, Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+import type { IImageNamedVariants } from '../types/image.ts';
+import type { IImageProviderRecord } from '../types/imageProvider.ts';
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+import { DtoImageTransformOptions } from './imageTransformOptions.tsx';
+
+export interface IDtoOptionsImageUploadResponse extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageUploadResponse>()
+export class DtoImageUploadResponse {
+  @Api.field(v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(z.string())
+  provider: keyof IImageProviderRecord;
+
+  @Api.field()
+  clientName: string;
+
+  @Api.field()
+  resourceId: string;
+
+  @Api.field(v.optional())
+  filename?: string;
+
+  @Api.field(v.optional())
+  contentType?: string;
+
+  @Api.field(v.optional())
+  size?: number;
+
+  @Api.field(v.optional())
+  width?: number;
+
+  @Api.field(v.optional())
+  height?: number;
+
+  @Api.field(v.optional())
+  requireSignedURLs?: boolean;
+
+  @Api.field(v.optional(), z.record(z.string(), $schema(DtoImageTransformOptions)))
+  variants?: IImageNamedVariants;
+
+  @Api.field(v.optional(), z.string())
+  imageScene?: keyof IImageSceneRecord;
+
+  @Api.field(v.optional())
+  uploadedAt?: Date;
+
+  @Api.field(v.optional())
+  url?: string;
+
+  @Api.field(v.optional())
+  signed?: boolean;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageUploadTokenRequest.ts

@@ -0,0 +1,24 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+export interface IDtoOptionsImageUploadTokenRequest extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageUploadTokenRequest>()
+export class DtoImageUploadTokenRequest {
+  @Api.field(z.string())
+  imageScene: keyof IImageSceneRecord;
+
+  @Api.field(z.number().int().positive())
+  size: number;
+
+  @Api.field(z.string())
+  mimeType: string;
+
+  @Api.field(v.optional(), z.number().int().positive())
+  expiresIn?: number;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageUploadTokenResponse.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+export interface IDtoOptionsImageUploadTokenResponse extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageUploadTokenResponse>()
+export class DtoImageUploadTokenResponse {
+  @Api.field(z.string())
+  token: string;
+
+  @Api.field(v.optional(), z.number().int().positive())
+  expiresIn?: number;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageUploadUrlRequest.ts

@@ -0,0 +1,33 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+export interface IDtoOptionsImageUploadUrlRequest extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageUploadUrlRequest>()
+export class DtoImageUploadUrlRequest {
+  @Api.field(z.string())
+  imageScene: keyof IImageSceneRecord;
+
+  @Api.field(z.string().url())
+  url: string;
+
+  @Api.field(z.number().int().positive())
+  size: number;
+
+  @Api.field(z.string())
+  mimeType: string;
+
+  @Api.field(v.optional())
+  filename?: string;
+
+  @Api.field(v.optional())
+  contentType?: string;
+
+  @Api.field(v.optional())
+  requireSignedURLs?: boolean;
+}

package/vona/src/suite-vendor/a-image/modules/a-image/src/dto/imageView.ts

@@ -0,0 +1,46 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $schema, Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+
+import type { IImageNamedVariants } from '../types/image.ts';
+import type { IImageSceneRecord } from '../types/imageScene.ts';
+
+import { DtoImageTransformOptions } from './imageTransformOptions.tsx';
+
+export interface IDtoOptionsImageView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsImageView>()
+export class DtoImageView {
+  @Api.field(v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(z.string())
+  url: string;
+
+  @Api.field(v.optional())
+  filename?: string;
+
+  @Api.field(v.optional())
+  width?: number;
+
+  @Api.field(v.optional())
+  height?: number;
+
+  @Api.field(z.string())
+  provider: string;
+
+  @Api.field(z.string())
+  clientName: string;
+
+  @Api.field(v.optional())
+  imageScene?: keyof IImageSceneRecord | string;
+
+  @Api.field(v.optional())
+  uploadedAt?: Date;
+
+  @Api.field(v.optional(), z.record(z.string(), $schema(DtoImageTransformOptions)))
+  variants?: IImageNamedVariants;
+}