cabloy 5.1.95 → 5.1.97

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

@@ -0,0 +1,58 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $schema, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+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 '../dto/imageTransformOptions.tsx';
+
+export interface IEntityOptionsImage extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsImage>('aImage')
+export class EntityImage extends EntityBase {
+  @Api.field(z.string())
+  providerName: 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())
+  meta?: Record<string, any>;
+
+  @Api.field(v.optional())
+  storagePath?: string;
+
+  @Api.field(v.optional())
+  deliveryBaseUrl?: string;
+
+  @Api.field(v.optional(), z.string())
+  imageScene?: keyof IImageSceneRecord;
+}

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

@@ -0,0 +1,24 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBaseSimple } from 'vona-module-a-orm';
+import z from 'zod';
+
+import type { IImageProviderClientOptions, IImageProviderRecord } from '../types/imageProvider.ts';
+
+export interface IEntityOptionsImageProvider extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsImageProvider>('aImageProvider')
+export class EntityImageProvider extends EntityBaseSimple {
+  @Api.field(v.default(false))
+  disabled: boolean;
+
+  @Api.field(z.string())
+  providerName: keyof IImageProviderRecord;
+
+  @Api.field()
+  clientName: string;
+
+  @Api.field(v.optional())
+  clientOptions?: IImageProviderClientOptions;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorImageProviderOptions } from '../types/imageProvider.ts';
+
+export function ImageProvider<T extends IDecoratorImageProviderOptions>(
+  options?: T,
+): ClassDecorator {
+  return createBeanDecorator('imageProvider', options);
+}

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

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorImageSceneOptions } from '../types/imageScene.ts';
+
+export function ImageScene(options?: IDecoratorImageSceneOptions): ClassDecorator {
+  return createBeanDecorator('imageScene', options);
+}

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

@@ -0,0 +1,46 @@
+import type {
+  IImageNamedVariants,
+  IImageVariantRequest,
+  TypeImageVariantName,
+} from '../types/image.ts';
+import type { IImageProviderResolvedVariant } from '../types/imageProvider.ts';
+
+export function resolveImageVariantRequest(
+  request: IImageVariantRequest,
+  defaultVariant: TypeImageVariantName,
+): IImageVariantRequest {
+  if (request.variantName && request.transformOptions) {
+    throw new Error('variantName and transformOptions are mutually exclusive');
+  }
+  if (request.variantName || request.transformOptions) return request;
+  return { variantName: defaultVariant };
+}
+
+export function resolveImageVariantByName(
+  variants: IImageNamedVariants | undefined,
+  variantName: TypeImageVariantName,
+): IImageProviderResolvedVariant {
+  if (variantName === 'original') {
+    return { variantName, transformOptions: {} };
+  }
+  const transformOptions = variants?.[variantName];
+  if (!transformOptions) {
+    throw new Error(`Image variant not found: ${variantName}`);
+  }
+  return { variantName, transformOptions };
+}
+
+export function resolveImageVariantRequestToTransform(
+  request: IImageVariantRequest,
+  defaultVariant: TypeImageVariantName,
+  variants: IImageNamedVariants | undefined,
+): IImageProviderResolvedVariant {
+  const requestResolved = resolveImageVariantRequest(request, defaultVariant);
+  if (requestResolved.variantName) {
+    return resolveImageVariantByName(variants, requestResolved.variantName);
+  }
+  return {
+    variantName: 'custom',
+    transformOptions: requestResolved.transformOptions ?? {},
+  };
+}

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

@@ -0,0 +1,3 @@
+export * from './imageProvider.ts';
+export * from './imageScene.ts';
+export * from './imageVariant.ts';

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

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityImage } from '../entity/image.ts';
+
+export interface IModelOptionsImage extends IDecoratorModelOptions<EntityImage> {}
+
+@Model<IModelOptionsImage>({ entity: EntityImage, disableDeleted: true })
+export class ModelImage extends BeanModelBase<EntityImage> {}

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

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityImageProvider } from '../entity/imageProvider.ts';
+
+export interface IModelOptionsImageProvider extends IDecoratorModelOptions<EntityImageProvider> {}
+
+@Model<IModelOptionsImageProvider>({ entity: EntityImageProvider, disableDeleted: true })
+export class ModelImageProvider extends BeanModelBase<EntityImageProvider> {}

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

@@ -0,0 +1,208 @@
+import type { TableIdentity } from 'table-identity';
+
+import type { IImageProviderClientOptions, IImageProviderRecord } from './imageProvider.ts';
+import type { IImageSceneRecord } from './imageScene.ts';
+
+// Extend this record via declaration merging to register project-specific named variants.
+// Example:
+// declare module 'vona-module-a-image' {
+//   interface IImageVariantNameRecord {
+//     hero: never;
+//   }
+// }
+export interface IImageVariantNameRecord {
+  original: never;
+  thumbnail: never;
+  small: never;
+  medium: never;
+  large: never;
+  cover: never;
+  avatar: never;
+}
+
+export interface IImageTransformOptions {
+  width?: number;
+  height?: number;
+  fit?: 'scale-down' | 'contain' | 'cover' | 'crop' | 'pad';
+  gravity?: 'auto' | 'center' | 'top' | 'bottom' | 'left' | 'right';
+  background?: string;
+  quality?: number;
+  format?: 'auto' | 'avif' | 'webp' | 'jpeg' | 'png';
+  dpr?: number;
+  rotate?: number;
+  sharpen?: number;
+}
+
+export type TypeImageVariantName = keyof IImageVariantNameRecord;
+
+export type IImageNamedVariants = Partial<Record<TypeImageVariantName, IImageTransformOptions>>;
+
+export type TypeImageDeliveryExpiry = Date | string | number;
+
+export interface IImageDeliveryOptions {
+  signed?: boolean;
+  expiresIn?: number;
+  expiresAt?: TypeImageDeliveryExpiry;
+  responseMode?: 'auto' | 'buffer' | 'url';
+}
+
+export interface IImageVariantRequestBase extends IImageDeliveryOptions {}
+
+// Request a declaration-merged named variant such as `thumbnail` or a project-specific key.
+export interface IImageVariantRequestByName extends IImageVariantRequestBase {
+  variantName?: TypeImageVariantName;
+  transformOptions?: never;
+}
+
+// Request an ad hoc image transform without registering a named variant.
+export interface IImageVariantRequestByTransform extends IImageVariantRequestBase {
+  variantName?: never;
+  transformOptions?: IImageTransformOptions;
+}
+
+export type IImageVariantRequest = IImageVariantRequestByName | IImageVariantRequestByTransform;
+
+export type TypeImageVariantInput = TypeImageVariantName | IImageVariantRequest | undefined;
+
+export type TypeImageMeta = Record<string, unknown>;
+
+export interface IImageUploadInput<TMeta extends TypeImageMeta = TypeImageMeta> {
+  file: string;
+  filename?: string;
+  contentType?: string;
+  size?: number;
+  requireSignedURLs?: boolean;
+  meta?: TMeta;
+}
+
+export interface IImageUploadUrlInput<TMeta extends TypeImageMeta = TypeImageMeta> {
+  url: string;
+  filename?: string;
+  contentType?: string;
+  requireSignedURLs?: boolean;
+  meta?: TMeta;
+}
+
+export interface IImageDirectUploadInput<TMeta extends TypeImageMeta = TypeImageMeta> {
+  filename?: string;
+  contentType?: string;
+  requireSignedURLs?: boolean;
+  meta?: TMeta;
+  expiry?: TypeImageDeliveryExpiry;
+  customId?: string;
+}
+
+export interface IImageUploadContextResolved<TMeta extends TypeImageMeta = TypeImageMeta> {
+  imageScene: keyof IImageSceneRecord;
+  providerName: keyof IImageProviderRecord;
+  clientName: string;
+  meta?: TMeta;
+}
+
+export interface IImageDownloadResult {
+  kind: 'url' | 'buffer';
+  url?: string;
+  buffer?: Buffer;
+  filename?: string;
+  contentType?: string;
+  signed?: boolean;
+}
+
+export interface IImageProviderResource<
+  TMeta extends TypeImageMeta = TypeImageMeta,
+  TRaw = unknown,
+> {
+  resourceId: string;
+  filename?: string;
+  contentType?: string;
+  size?: number;
+  width?: number;
+  height?: number;
+  requireSignedURLs?: boolean;
+  variants?: IImageNamedVariants;
+  meta?: TMeta;
+  storagePath?: string;
+  deliveryBaseUrl?: string;
+  raw?: TRaw;
+}
+
+export interface IImageProviderDirectUploadResource<
+  TMeta extends TypeImageMeta = TypeImageMeta,
+  TRaw = unknown,
+> extends IImageProviderResource<TMeta, TRaw> {
+  uploadUrl: string;
+  draft?: boolean;
+}
+
+export interface IImageResource<
+  TMeta extends TypeImageMeta = TypeImageMeta,
+  TRaw = unknown,
+> extends IImageProviderResource<TMeta, TRaw> {
+  id: TableIdentity;
+  provider: keyof IImageProviderRecord;
+  clientName: string;
+  imageScene?: keyof IImageSceneRecord | string;
+  uploadedAt?: Date;
+}
+
+export interface IImageDirectUploadResult<
+  TMeta extends TypeImageMeta = TypeImageMeta,
+  TRaw = unknown,
+> extends IImageResource<TMeta, TRaw> {
+  uploadUrl: string;
+  draft?: boolean;
+}
+
+export interface IImageView {
+  id: TableIdentity;
+  url: string;
+  filename?: string;
+  width?: number;
+  height?: number;
+  provider: keyof IImageProviderRecord;
+  clientName: string;
+  imageScene?: keyof IImageSceneRecord | string;
+  uploadedAt?: Date;
+  variants?: IImageNamedVariants;
+  signed?: boolean;
+}
+
+export interface IImageUploadOptions<
+  TClientOptions extends IImageProviderClientOptions = IImageProviderClientOptions,
+  TMeta extends TypeImageMeta = TypeImageMeta,
+> {
+  clientName?: string;
+  clientOptions?: TClientOptions;
+  meta?: TMeta;
+  imageScene?: keyof IImageSceneRecord;
+}
+
+export interface IImageUploadPolicyResolved<
+  TMeta extends TypeImageMeta = TypeImageMeta,
+> extends IImageUploadContextResolved<TMeta> {
+  maxSize?: number;
+  mimeTypes?: string[];
+  extensions?: string[];
+  multiple?: boolean;
+  fileSize: number;
+  mimeType: string;
+}
+
+export interface IImageUploadTokenPayload<
+  TMeta extends TypeImageMeta = TypeImageMeta,
+> extends IImageUploadPolicyResolved<TMeta> {
+  kind: 'imageUpload';
+}
+
+export interface IImageDeliveryTokenPayload {
+  kind: 'imageDelivery';
+  imageId: TableIdentity;
+  request: IImageVariantRequest;
+  targetUrl: string;
+}
+
+declare module 'vona' {
+  export interface ILoggerChildRecord {
+    image: never;
+  }
+}

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

@@ -0,0 +1,110 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion, TypeOnionOptionsEnableSimple } from 'vona-module-a-onion';
+
+import type { EntityImage } from '../entity/image.ts';
+import type { EntityImageProvider } from '../entity/imageProvider.ts';
+import type {
+  IImageDeliveryOptions,
+  IImageDirectUploadInput,
+  IImageDownloadResult,
+  IImageNamedVariants,
+  IImageProviderDirectUploadResource,
+  IImageProviderResource,
+  IImageTransformOptions,
+  IImageUploadInput,
+  IImageUploadUrlInput,
+  IImageVariantRequest,
+  TypeImageVariantName,
+} from './image.ts';
+
+export type TypeImageProviderPick = Partial<
+  Pick<EntityImageProvider, 'id' | 'providerName' | 'clientName'>
+>;
+
+export interface IImageProviderRecord {}
+
+export interface IImageProviderClientRecord {
+  default: never;
+}
+export interface IImageProviderClientOptions {
+  deliveryBaseUrl?: string;
+  variants?: IImageNamedVariants;
+  requireSignedURLs?: boolean;
+  signedDeliveryKind?: 'proxy' | 'provider';
+}
+
+export type TypeImageProviderClientOptions<T> =
+  T extends IDecoratorImageProviderOptions<any, infer O> ? O : never;
+
+export type TypeImageProviderClientName<T> =
+  T extends IDecoratorImageProviderOptions<infer R, any> ? keyof R : never;
+
+export interface IDecoratorImageProviderOptions<
+  R extends IImageProviderClientRecord = IImageProviderClientRecord,
+  T extends IImageProviderClientOptions = IImageProviderClientOptions,
+> extends TypeOnionOptionsEnableSimple {
+  base?: T;
+  clients?: { [K in keyof R]?: T };
+}
+
+// Provider-internal resolved variant names include both declaration-merged named variants
+// and the internal `custom` sentinel used for ad hoc transform requests.
+export type TypeImageProviderResolvedVariantName = TypeImageVariantName | 'custom';
+
+export interface IImageProviderResolvedVariant {
+  variantName: TypeImageProviderResolvedVariantName;
+  transformOptions: IImageTransformOptions;
+}
+
+export interface IImageProviderExecute<
+  T extends IImageProviderClientOptions = IImageProviderClientOptions,
+  O extends IDecoratorImageProviderOptions = IDecoratorImageProviderOptions,
+> {
+  upload(input: IImageUploadInput, clientOptions: T, options: O): Promise<IImageProviderResource>;
+  uploadUrl?(
+    input: IImageUploadUrlInput,
+    clientOptions: T,
+    options: O,
+  ): Promise<IImageProviderResource>;
+  createDirectUpload?(
+    input: IImageDirectUploadInput,
+    clientOptions: T,
+    options: O,
+  ): Promise<IImageProviderDirectUploadResource>;
+  get(
+    image: EntityImage,
+    clientOptions: T,
+    options: O,
+  ): Promise<IImageProviderResource | undefined>;
+  delete(image: EntityImage, clientOptions: T, options: O): Promise<void>;
+  getVariantUrl(
+    image: EntityImage,
+    request: IImageVariantRequest,
+    clientOptions: T,
+    options: O,
+    deliveryOptions?: IImageDeliveryOptions,
+  ): Promise<string>;
+  download?(
+    image: EntityImage,
+    request: IImageVariantRequest,
+    clientOptions: T,
+    options: O,
+    deliveryOptions?: IImageDeliveryOptions,
+  ): Promise<IImageDownloadResult>;
+}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    imageProvider: ServiceOnion<IImageProviderRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    imageProvider: OmitNever<IImageProviderRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    imageProvider: never;
+  }
+}

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

@@ -0,0 +1,52 @@
+import type { OmitNever, VonaContext } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+
+import type { IImageProviderRecord } from './imageProvider.ts';
+
+export interface IImageSceneRecord {}
+
+export interface IImageSceneOptionsUpload {
+  maxSize?: number;
+  mimeTypes?: string[];
+  extensions?: string[];
+  multiple?: boolean;
+}
+
+export interface IDecoratorImageSceneOptionsProvider {
+  providerName?: keyof IImageProviderRecord;
+  clientName?: string;
+}
+
+export type TypeDecoratorImageSceneOptionsProvider =
+  | TypeImageSceneOptionsResolver
+  | IDecoratorImageSceneOptionsProvider;
+
+export type TypeImageSceneOptionsResolver = (
+  ctx: VonaContext,
+) => Promise<IDecoratorImageSceneOptionsProvider>;
+
+export type TypeImageSceneOptionsMetaResolver = (
+  ctx: VonaContext,
+) => Promise<Record<string, any> | undefined> | Record<string, any> | undefined;
+
+export interface IDecoratorImageSceneOptions {
+  provider?: TypeDecoratorImageSceneOptionsProvider;
+  upload?: IImageSceneOptionsUpload;
+  meta?: Record<string, any> | TypeImageSceneOptionsMetaResolver;
+}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    imageScene: ServiceOnion<IImageSceneRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    imageScene: OmitNever<IImageSceneRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    imageScene: never;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './image.ts';
+export * from './imageProvider.ts';
+export * from './imageScene.ts';

package/vona/src/suite-vendor/a-image/modules/a-image/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-image/modules/a-image/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-image/modules/image-cloudflare/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "vona-module-image-cloudflare",
+  "version": "5.0.1",
+  "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"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "exports.\\..import"
+    ]
+  },
+  "title": "image-cloudflare",
+  "vonaModule": {
+    "dependencies": {
+      "a-image": "5.0.0"
+    }
+  }
+}