cabloy 5.1.95 → 5.1.97

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

@@ -0,0 +1,89 @@
+// eslint-disable
+/** service: begin */
+export * from '../service/imageCloudflare.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  export interface IServiceRecord {
+    'image-cloudflare:imageCloudflare': never;
+  }
+}
+declare module 'vona-module-image-cloudflare' {
+  export interface ServiceImageCloudflare {
+    /** @internal */
+    get scope(): ScopeModuleImageCloudflare;
+  }
+
+  export interface ServiceImageCloudflare {
+    get $beanFullName(): 'image-cloudflare.service.imageCloudflare';
+    get $onionName(): 'image-cloudflare:imageCloudflare';
+  }
+}
+/** service: end */
+/** service: begin */
+import type { ServiceImageCloudflare } from '../service/imageCloudflare.ts';
+export interface IModuleService {
+  imageCloudflare: ServiceImageCloudflare;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'image-cloudflare.service.imageCloudflare': ServiceImageCloudflare;
+  }
+}
+/** service: end */
+/** imageProvider: begin */
+export * from '../bean/imageProvider.cloudflare.ts';
+import type { IImageProviderOptionsCloudflare } from '../bean/imageProvider.cloudflare.ts';
+import 'vona-module-a-image';
+declare module 'vona-module-a-image' {
+  export interface IImageProviderRecord {
+    'image-cloudflare:cloudflare': IImageProviderOptionsCloudflare;
+  }
+}
+declare module 'vona-module-image-cloudflare' {
+  export interface ImageProviderCloudflare {
+    /** @internal */
+    get scope(): ScopeModuleImageCloudflare;
+  }
+
+  export interface ImageProviderCloudflare {
+    get $beanFullName(): 'image-cloudflare.imageProvider.cloudflare';
+    get $onionName(): 'image-cloudflare:cloudflare';
+    get $onionOptions(): IImageProviderOptionsCloudflare;
+  }
+}
+/** imageProvider: end */
+/** imageProvider: begin */
+import type { ImageProviderCloudflare } from '../bean/imageProvider.cloudflare.ts';
+export interface IModuleImageProvider {
+  cloudflare: ImageProviderCloudflare;
+}
+/** imageProvider: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleImageCloudflare extends BeanScopeBase {}
+
+export interface ScopeModuleImageCloudflare {
+  util: BeanScopeUtil;
+  service: IModuleService;
+  imageProvider: IModuleImageProvider;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'image-cloudflare': ScopeModuleImageCloudflare;
+  }
+
+  export interface IBeanScopeContainer {
+    imageCloudflare: ScopeModuleImageCloudflare;
+  }
+}
+/** scope: end */

package/vona/src/suite-vendor/a-image/modules/image-cloudflare/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'image-cloudflare';
+export { ScopeModuleImageCloudflare as ScopeModule } from './index.ts';

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

@@ -0,0 +1,155 @@
+import type {
+  IDecoratorImageProviderOptions,
+  IImageDeliveryOptions,
+  IImageDirectUploadInput,
+  IImageDownloadResult,
+  IImageProviderClientOptions,
+  IImageProviderClientRecord,
+  IImageProviderExecute,
+  IImageProviderResource,
+  IImageUploadInput,
+  IImageUploadUrlInput,
+  IImageVariantRequest,
+  TypeImageProviderResolvedVariantName,
+} from 'vona-module-a-image';
+import type { EntityImage } from 'vona-module-a-image';
+
+import { BeanBase } from 'vona';
+import { resolveImageVariantRequestToTransform } from 'vona-module-a-image';
+import { ImageProvider } from 'vona-module-a-image';
+
+export interface IImageProviderCloudflareClientRecord extends IImageProviderClientRecord {}
+
+export interface IImageProviderCloudflareClientOptions extends IImageProviderClientOptions {
+  accountId?: string;
+  apiToken?: string;
+  accountHash?: string;
+  apiBaseUrl?: string;
+  signingKey?: string;
+  flexibleVariants?: boolean;
+  customDomain?: string;
+}
+
+export interface IImageProviderOptionsCloudflare extends IDecoratorImageProviderOptions<
+  IImageProviderCloudflareClientRecord,
+  IImageProviderCloudflareClientOptions
+> {}
+
+@ImageProvider<IImageProviderOptionsCloudflare>({
+  base: {
+    signedDeliveryKind: 'provider',
+    variants: {
+      original: {},
+    },
+  },
+})
+export class ImageProviderCloudflare extends BeanBase implements IImageProviderExecute {
+  async upload(
+    input: IImageUploadInput,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    _options: IImageProviderOptionsCloudflare,
+  ): Promise<IImageProviderResource> {
+    return await this.scope.service.imageCloudflare.upload(input, clientOptions);
+  }
+
+  async uploadUrl(
+    input: IImageUploadUrlInput,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    _options: IImageProviderOptionsCloudflare,
+  ) {
+    return await this.scope.service.imageCloudflare.uploadUrl(input, clientOptions);
+  }
+
+  async createDirectUpload(
+    input: IImageDirectUploadInput,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    _options: IImageProviderOptionsCloudflare,
+  ) {
+    return await this.scope.service.imageCloudflare.createDirectUpload(input, clientOptions);
+  }
+
+  async get(
+    image: EntityImage,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    _options: IImageProviderOptionsCloudflare,
+  ) {
+    return {
+      resourceId: image.resourceId,
+      filename: image.filename,
+      contentType: image.contentType,
+      size: image.size,
+      width: image.width,
+      height: image.height,
+      requireSignedURLs: image.requireSignedURLs ?? clientOptions.requireSignedURLs,
+      variants: image.variants ?? clientOptions.variants,
+      meta: image.meta,
+      deliveryBaseUrl: image.deliveryBaseUrl ?? clientOptions.deliveryBaseUrl,
+    };
+  }
+
+  async delete(
+    image: EntityImage,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    _options: IImageProviderOptionsCloudflare,
+  ) {
+    await this.scope.service.imageCloudflare.remove(image, clientOptions);
+  }
+
+  async getVariantUrl(
+    image: EntityImage,
+    request: IImageVariantRequest,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    _options: IImageProviderOptionsCloudflare,
+    deliveryOptions?: IImageDeliveryOptions,
+  ) {
+    const variants = image.variants ?? clientOptions.variants;
+    const resolved = resolveImageVariantRequestToTransform(request, 'original', variants);
+    return this._buildVariantUrl(
+      image,
+      resolved.variantName,
+      resolved.transformOptions,
+      {
+        ...clientOptions,
+        deliveryBaseUrl: image.deliveryBaseUrl ?? clientOptions.deliveryBaseUrl,
+        requireSignedURLs: image.requireSignedURLs ?? clientOptions.requireSignedURLs,
+      },
+      deliveryOptions,
+    );
+  }
+
+  async download(
+    image: EntityImage,
+    request: IImageVariantRequest,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    options: IImageProviderOptionsCloudflare,
+    deliveryOptions?: IImageDeliveryOptions,
+  ): Promise<IImageDownloadResult> {
+    return {
+      kind: 'url',
+      url: await this.getVariantUrl(image, request, clientOptions, options, deliveryOptions),
+      filename: image.filename,
+      contentType: image.contentType,
+      signed: !!(
+        deliveryOptions?.signed ??
+        image.requireSignedURLs ??
+        clientOptions.requireSignedURLs
+      ),
+    };
+  }
+
+  private _buildVariantUrl(
+    image: EntityImage,
+    variantName: TypeImageProviderResolvedVariantName,
+    transformOptions: Record<string, any>,
+    clientOptions: IImageProviderCloudflareClientOptions,
+    deliveryOptions?: IImageDeliveryOptions,
+  ) {
+    return this.scope.service.imageCloudflare.buildVariantUrl(
+      image,
+      variantName,
+      transformOptions,
+      clientOptions,
+      deliveryOptions,
+    );
+  }
+}

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

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

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

@@ -0,0 +1,112 @@
+import type {
+  IImageDeliveryOptions,
+  IImageTransformOptions,
+  TypeImageVariantName,
+} from 'vona-module-a-image';
+
+import { createHmac } from 'node:crypto';
+
+export interface ICloudflareImageUrlOptions extends IImageDeliveryOptions {
+  accountHash?: string;
+  deliveryBaseUrl?: string;
+  signingKey?: string;
+}
+
+export function buildCloudflareImageUrl(
+  resourceId: string,
+  variantName: TypeImageVariantName | 'custom',
+  transformOptions: IImageTransformOptions,
+  options: ICloudflareImageUrlOptions,
+) {
+  const baseUrl = resolveCloudflareDeliveryBaseUrl(options);
+  const resourcePath = encodeCloudflareResourceId(resourceId);
+  const variantPath =
+    variantName === 'custom'
+      ? buildCloudflareTransformPath(transformOptions)
+      : normalizeCloudflareVariantName(variantName);
+  const url = new URL(`${baseUrl}/${resourcePath}/${variantPath}`);
+  if (options.signed) {
+    signCloudflareImageUrl(url, options);
+  }
+  return url.toString();
+}
+
+export function resolveCloudflareDeliveryBaseUrl(options: {
+  accountHash?: string;
+  deliveryBaseUrl?: string;
+}) {
+  if (options.deliveryBaseUrl) {
+    return options.deliveryBaseUrl.replace(/\/$/, '');
+  }
+  if (!options.accountHash) {
+    throw new Error('Cloudflare accountHash or deliveryBaseUrl is required');
+  }
+  return `https://imagedelivery.net/${options.accountHash}`;
+}
+
+export function resolveCloudflareDeliveryBaseUrlFromVariantUrl(url?: string) {
+  if (!url) return undefined;
+  const parsed = new URL(url);
+  const segments = parsed.pathname.split('/').filter(Boolean);
+  if (segments.length < 2) return undefined;
+  return `${parsed.origin}/${segments[0]}`;
+}
+
+export function encodeCloudflareResourceId(resourceId: string) {
+  return resourceId
+    .split('/')
+    .map(segment => encodeURIComponent(segment))
+    .join('/');
+}
+
+export function buildCloudflareTransformPath(transformOptions: IImageTransformOptions) {
+  const entries: Array<[string, string | number]> = [];
+  if (transformOptions.width !== undefined) entries.push(['w', transformOptions.width]);
+  if (transformOptions.height !== undefined) entries.push(['h', transformOptions.height]);
+  if (transformOptions.fit !== undefined) entries.push(['fit', transformOptions.fit]);
+  if (transformOptions.gravity !== undefined) entries.push(['gravity', transformOptions.gravity]);
+  if (transformOptions.background !== undefined)
+    entries.push(['background', transformOptions.background]);
+  if (transformOptions.quality !== undefined) entries.push(['quality', transformOptions.quality]);
+  if (transformOptions.format !== undefined && transformOptions.format !== 'auto') {
+    entries.push(['format', transformOptions.format]);
+  }
+  if (transformOptions.dpr !== undefined) entries.push(['dpr', transformOptions.dpr]);
+  if (transformOptions.rotate !== undefined) entries.push(['rotate', transformOptions.rotate]);
+  if (transformOptions.sharpen !== undefined) entries.push(['sharpen', transformOptions.sharpen]);
+  if (entries.length === 0) return 'public';
+  return entries.map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`).join(',');
+}
+
+export function normalizeCloudflareVariantName(variantName: TypeImageVariantName | 'custom') {
+  if (variantName === 'original') return 'public';
+  return variantName;
+}
+
+export function signCloudflareImageUrl(url: URL, options: ICloudflareImageUrlOptions) {
+  if (!options.signingKey) {
+    throw new Error('Cloudflare signingKey is required for signed delivery');
+  }
+  const expiry = resolveExpiryTimestamp(options);
+  url.searchParams.set('exp', String(expiry));
+  const stringToSign = `${url.pathname}?${url.searchParams.toString()}`;
+  const sig = createHmac('sha256', options.signingKey).update(stringToSign).digest('hex');
+  url.searchParams.set('sig', sig);
+}
+
+function resolveExpiryTimestamp(options: IImageDeliveryOptions) {
+  if (options.expiresAt !== undefined) {
+    const value =
+      options.expiresAt instanceof Date
+        ? options.expiresAt.getTime()
+        : typeof options.expiresAt === 'string'
+          ? new Date(options.expiresAt).getTime()
+          : Number(options.expiresAt);
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`Invalid expiresAt for signed delivery: ${String(options.expiresAt)}`);
+    }
+    return Math.floor(value / 1000);
+  }
+  const expiresIn = options.expiresIn ?? 60 * 10;
+  return Math.floor(Date.now() / 1000) + expiresIn;
+}

package/vona/src/suite-vendor/a-image/modules/image-cloudflare/src/service/imageCloudflare.ts

@@ -0,0 +1,273 @@
+import type {
+  EntityImage,
+  IImageDeliveryOptions,
+  IImageDirectUploadInput,
+  IImageProviderDirectUploadResource,
+  IImageProviderResource,
+  IImageUploadInput,
+  IImageUploadUrlInput,
+} from 'vona-module-a-image';
+
+import fse from 'fs-extra';
+import path from 'node:path';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { IImageProviderCloudflareClientOptions } from '../bean/imageProvider.cloudflare.ts';
+
+import {
+  buildCloudflareImageUrl,
+  resolveCloudflareDeliveryBaseUrl,
+  resolveCloudflareDeliveryBaseUrlFromVariantUrl,
+} from '../lib/cloudflareImageUrl.ts';
+
+interface ICloudflareApiEnvelope<T> {
+  result: T;
+  success: boolean;
+  errors?: Array<{ message?: string }>;
+  messages?: Array<{ message?: string }>;
+}
+
+interface ICloudflareImageResult {
+  id: string;
+  filename?: string;
+  uploaded?: string;
+  requireSignedURLs?: boolean;
+  variants?: string[];
+  metadata?: Record<string, unknown>;
+  draft?: boolean;
+}
+
+interface ICloudflareClientOptionsNormalized extends IImageProviderCloudflareClientOptions {
+  accountId: string;
+  apiToken: string;
+  apiBaseUrl: string;
+  deliveryBaseUrl?: string;
+}
+
+@Service()
+export class ServiceImageCloudflare extends BeanBase {
+  async upload(
+    input: IImageUploadInput,
+    options: IImageProviderCloudflareClientOptions,
+  ): Promise<IImageProviderResource> {
+    const normalized = this._normalizeClientOptions(options);
+    const form = new FormData();
+    const buffer = await fse.readFile(input.file);
+    const filename = input.filename ?? path.basename(input.file);
+    form.append('file', new Blob([buffer], { type: input.contentType }), filename);
+    this._appendUploadFields(form, {
+      requireSignedURLs: input.requireSignedURLs,
+      metadata: input.meta,
+    });
+    const result = await this._request<ICloudflareImageResult>(normalized, '/images/v1', {
+      method: 'POST',
+      body: form,
+    });
+    const stat = await fse.stat(input.file);
+    return this._mapImageResource(result, normalized, {
+      filename,
+      contentType: input.contentType,
+      size: input.size ?? Number(stat.size),
+      meta: input.meta,
+      requireSignedURLs: input.requireSignedURLs,
+    });
+  }
+
+  async uploadUrl(
+    input: IImageUploadUrlInput,
+    options: IImageProviderCloudflareClientOptions,
+  ): Promise<IImageProviderResource> {
+    const normalized = this._normalizeClientOptions(options);
+    const form = new FormData();
+    form.append('url', input.url);
+    this._appendUploadFields(form, {
+      requireSignedURLs: input.requireSignedURLs,
+      metadata: input.meta,
+    });
+    const result = await this._request<ICloudflareImageResult>(normalized, '/images/v1', {
+      method: 'POST',
+      body: form,
+    });
+    return this._mapImageResource(result, normalized, {
+      filename: input.filename ?? result.filename,
+      contentType: input.contentType,
+      meta: input.meta,
+      requireSignedURLs: input.requireSignedURLs,
+    });
+  }
+
+  async createDirectUpload(
+    input: IImageDirectUploadInput,
+    options: IImageProviderCloudflareClientOptions,
+  ): Promise<IImageProviderDirectUploadResource> {
+    const normalized = this._normalizeClientOptions(options);
+    const form = new FormData();
+    this._appendUploadFields(form, {
+      requireSignedURLs: input.requireSignedURLs,
+      metadata: input.meta,
+      expiry: input.expiry,
+      id: input.customId,
+    });
+    const result = await this._request<ICloudflareImageResult & { uploadURL: string }>(
+      normalized,
+      '/images/v2/direct_upload',
+      {
+        method: 'POST',
+        body: form,
+      },
+    );
+    const resource = this._mapImageResource(result, normalized, {
+      filename: input.filename,
+      contentType: input.contentType,
+      meta: input.meta,
+      requireSignedURLs: input.requireSignedURLs,
+    });
+    return {
+      ...resource,
+      uploadUrl: result.uploadURL,
+      draft: true,
+    };
+  }
+
+  async remove(
+    image: Pick<EntityImage, 'resourceId'>,
+    options: IImageProviderCloudflareClientOptions,
+  ) {
+    const normalized = this._normalizeClientOptions(options);
+    const response = await fetch(
+      `${normalized.apiBaseUrl}/accounts/${normalized.accountId}/images/v1/${encodeURIComponent(image.resourceId)}`,
+      {
+        method: 'DELETE',
+        headers: this._createHeaders(normalized),
+      },
+    );
+    if (response.status === 404) return;
+    await this._parseEnvelope<unknown>(response);
+  }
+
+  buildVariantUrl(
+    image: Pick<EntityImage, 'resourceId' | 'deliveryBaseUrl' | 'requireSignedURLs'>,
+    variantName: string | 'custom',
+    transformOptions: Record<string, any>,
+    options: IImageProviderCloudflareClientOptions,
+    deliveryOptions?: IImageDeliveryOptions,
+  ) {
+    const normalized = this._normalizeClientOptions(options);
+    return buildCloudflareImageUrl(image.resourceId, variantName as any, transformOptions, {
+      accountHash: normalized.accountHash,
+      deliveryBaseUrl: image.deliveryBaseUrl ?? normalized.deliveryBaseUrl,
+      signingKey: normalized.signingKey,
+      signed: deliveryOptions?.signed ?? image.requireSignedURLs ?? normalized.requireSignedURLs,
+      expiresAt: deliveryOptions?.expiresAt,
+      expiresIn: deliveryOptions?.expiresIn,
+    });
+  }
+
+  private _appendUploadFields(
+    form: FormData,
+    data: {
+      requireSignedURLs?: boolean;
+      metadata?: Record<string, unknown>;
+      expiry?: string | number | Date;
+      id?: string;
+    },
+  ) {
+    if (data.requireSignedURLs !== undefined) {
+      form.append('requireSignedURLs', String(data.requireSignedURLs));
+    }
+    if (data.metadata !== undefined) {
+      form.append('metadata', JSON.stringify(data.metadata));
+    }
+    if (data.expiry !== undefined) {
+      form.append(
+        'expiry',
+        data.expiry instanceof Date ? data.expiry.toISOString() : String(data.expiry),
+      );
+    }
+    if (data.id) {
+      form.append('id', data.id);
+    }
+  }
+
+  private _normalizeClientOptions(options: IImageProviderCloudflareClientOptions) {
+    const accountId = options.accountId;
+    const apiToken = options.apiToken;
+    if (!accountId) {
+      throw new Error('Cloudflare Images accountId is required');
+    }
+    if (!apiToken) {
+      throw new Error('Cloudflare Images apiToken is required');
+    }
+    return {
+      ...options,
+      accountId,
+      apiToken,
+      apiBaseUrl: (options.apiBaseUrl ?? 'https://api.cloudflare.com/client/v4').replace(/\/$/, ''),
+      deliveryBaseUrl: options.deliveryBaseUrl
+        ? resolveCloudflareDeliveryBaseUrl(options)
+        : undefined,
+    };
+  }
+
+  private _createHeaders(options: { apiToken: string }) {
+    return {
+      Authorization: `Bearer ${options.apiToken}`,
+    };
+  }
+
+  private async _request<T>(
+    options: ICloudflareClientOptionsNormalized,
+    apiPath: string,
+    init: RequestInit,
+  ) {
+    const response = await fetch(`${options.apiBaseUrl}/accounts/${options.accountId}${apiPath}`, {
+      ...init,
+      headers: {
+        ...this._createHeaders(options),
+        ...(init.headers ?? {}),
+      },
+    });
+    return await this._parseEnvelope<T>(response);
+  }
+
+  private async _parseEnvelope<T>(response: Response) {
+    const data = (await response.json()) as ICloudflareApiEnvelope<T>;
+    if (!response.ok || !data.success) {
+      const message = data.errors
+        ?.map(item => item.message)
+        .filter(Boolean)
+        .join('; ');
+      throw new Error(message || `Cloudflare Images request failed: ${response.status}`);
+    }
+    return data.result;
+  }
+
+  private _mapImageResource(
+    result: ICloudflareImageResult,
+    options: ICloudflareClientOptionsNormalized,
+    data: {
+      filename?: string;
+      contentType?: string;
+      size?: number;
+      meta?: Record<string, unknown>;
+      requireSignedURLs?: boolean;
+    },
+  ): IImageProviderResource {
+    const deliveryBaseUrl =
+      options.deliveryBaseUrl ??
+      resolveCloudflareDeliveryBaseUrlFromVariantUrl(result.variants?.[0]);
+    return {
+      resourceId: result.id,
+      filename: data.filename ?? result.filename,
+      contentType: data.contentType,
+      size: data.size,
+      requireSignedURLs:
+        data.requireSignedURLs ?? result.requireSignedURLs ?? options.requireSignedURLs,
+      variants: options.variants,
+      meta: data.meta,
+      deliveryBaseUrl,
+      raw: result,
+    };
+  }
+}

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

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