@purpleschool/multisite 0.0.27 → 0.0.29

package/build/queries/user/get-user-payments.command.d.ts

@@ -18,34 +18,34 @@ export declare namespace GetUserPaymentsCommand {
         updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
-        description: string;
-        userId: string;
-        productId: string | null;
-        updatedAt: string | Date;
-        subscriptionId: string | null;
-        currency: string;
-        sum: number;
         orderType: ORDER_TYPE;
         orderStatus: ORDER_STATUS;
+        description: string;
+        productId: string | null;
         productName: string | null;
+        subscriptionId: string | null;
         subscriptionName: string | null;
         paymentStatus: PAYMENT_STATUS;
+        userId: string;
         userEmail: string;
+        sum: number;
+        currency: string;
+        updatedAt: string | Date;
     }, {
         uuid: string;
-        description: string;
-        userId: string;
-        productId: string | null;
-        updatedAt: string | Date;
-        subscriptionId: string | null;
-        currency: string;
-        sum: number;
         orderType: ORDER_TYPE;
         orderStatus: ORDER_STATUS;
+        description: string;
+        productId: string | null;
         productName: string | null;
+        subscriptionId: string | null;
         subscriptionName: string | null;
         paymentStatus: PAYMENT_STATUS;
+        userId: string;
         userEmail: string;
+        sum: number;
+        currency: string;
+        updatedAt: string | Date;
     }>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodArray<z.ZodObject<{
@@ -65,68 +65,68 @@ export declare namespace GetUserPaymentsCommand {
             updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
         }, "strip", z.ZodTypeAny, {
             uuid: string;
-            description: string;
-            userId: string;
-            productId: string | null;
-            updatedAt: string | Date;
-            subscriptionId: string | null;
-            currency: string;
-            sum: number;
             orderType: ORDER_TYPE;
             orderStatus: ORDER_STATUS;
+            description: string;
+            productId: string | null;
             productName: string | null;
+            subscriptionId: string | null;
             subscriptionName: string | null;
             paymentStatus: PAYMENT_STATUS;
+            userId: string;
             userEmail: string;
+            sum: number;
+            currency: string;
+            updatedAt: string | Date;
         }, {
             uuid: string;
-            description: string;
-            userId: string;
-            productId: string | null;
-            updatedAt: string | Date;
-            subscriptionId: string | null;
-            currency: string;
-            sum: number;
             orderType: ORDER_TYPE;
             orderStatus: ORDER_STATUS;
+            description: string;
+            productId: string | null;
             productName: string | null;
+            subscriptionId: string | null;
             subscriptionName: string | null;
             paymentStatus: PAYMENT_STATUS;
+            userId: string;
             userEmail: string;
+            sum: number;
+            currency: string;
+            updatedAt: string | Date;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         data: {
             uuid: string;
-            description: string;
-            userId: string;
-            productId: string | null;
-            updatedAt: string | Date;
-            subscriptionId: string | null;
-            currency: string;
-            sum: number;
             orderType: ORDER_TYPE;
             orderStatus: ORDER_STATUS;
+            description: string;
+            productId: string | null;
             productName: string | null;
+            subscriptionId: string | null;
             subscriptionName: string | null;
             paymentStatus: PAYMENT_STATUS;
+            userId: string;
             userEmail: string;
+            sum: number;
+            currency: string;
+            updatedAt: string | Date;
         }[];
     }, {
         data: {
             uuid: string;
-            description: string;
-            userId: string;
-            productId: string | null;
-            updatedAt: string | Date;
-            subscriptionId: string | null;
-            currency: string;
-            sum: number;
             orderType: ORDER_TYPE;
             orderStatus: ORDER_STATUS;
+            description: string;
+            productId: string | null;
             productName: string | null;
+            subscriptionId: string | null;
             subscriptionName: string | null;
             paymentStatus: PAYMENT_STATUS;
+            userId: string;
             userEmail: string;
+            sum: number;
+            currency: string;
+            updatedAt: string | Date;
         }[];
     }>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/queries/user/get-user.command.d.ts

@@ -10,36 +10,36 @@ export declare namespace GetUserCommand {
             siteId: z.ZodString;
             tokenBonusBalance: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            email: string;
             uuid: string;
-            siteId: string;
+            email: string;
             role: USER_ROLE;
             status: USER_STATUS;
+            siteId: string;
             tokenBonusBalance: number;
         }, {
-            email: string;
             uuid: string;
-            siteId: string;
+            email: string;
             role: USER_ROLE;
             status: USER_STATUS;
+            siteId: string;
             tokenBonusBalance: number;
         }>;
     }, "strip", z.ZodTypeAny, {
         data: {
-            email: string;
             uuid: string;
-            siteId: string;
+            email: string;
             role: USER_ROLE;
             status: USER_STATUS;
+            siteId: string;
             tokenBonusBalance: number;
         };
     }, {
         data: {
-            email: string;
             uuid: string;
-            siteId: string;
+            email: string;
             role: USER_ROLE;
             status: USER_STATUS;
+            siteId: string;
             tokenBonusBalance: number;
         };
     }>;

package/commands/image-editor/proxy-image-editor-callback.command.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 export namespace ProxyImageEditorCallbackCommand {
     export const RequestSchema = z.object({
         jobId: z.string().min(1),
-        imageUrl: z.string().url().optional(),
+        imageUrl: z.string().min(1).optional(),
         error: z.string().optional(),
     });
     export type Request = z.infer<typeof RequestSchema>;

package/constants/email/email-endpoint.ts

@@ -1 +1 @@
-export const EmailEndpoint = 'https://api.rusender.ru/v1/email/send';
+export const EmailEndpoint = 'https://api.rusender.ru/api/v1/external-mails/send';

package/constants/errors/errors.ts

@@ -21,6 +21,11 @@ export const ERRORS = {
         code: 'TENANT_003',
         httpCode: 500,
     },
+    TOOL_NOT_AVAILABLE_FOR_SITE: {
+        message: 'Инструмент недоступен для сайта',
+        code: 'TOOL_001',
+        httpCode: 403,
+    },
 
     // AUTH
     AUTH_REGISTER_CONFLICT: {
@@ -536,6 +541,11 @@ export const ERRORS = {
         code: 'IMAGE_EDITOR_009',
         httpCode: 403,
     },
+    IMAGE_EDITOR_IMAGE_REQUIRED: {
+        message: 'Для редактирования изображения необходимо прикрепить хотя бы одно изображение',
+        code: 'IMAGE_EDITOR_015',
+        httpCode: 400,
+    },
     IMAGE_EDITOR_NOT_ENOUGH_TOKENS: {
         message: 'Недостаточно токенов',
         code: 'IMAGE_EDITOR_003',

package/constants/image-editor/enums/image-editing-strategy.enum.ts

@@ -6,4 +6,5 @@ export enum IMAGE_EDITING_STRATEGY {
     NANO_BANANA_PRO_CALLBACK = 'NANO_BANANA_PRO_CALLBACK',
     NANO_BANANA_PRO_POLLING = 'NANO_BANANA_PRO_POLLING',
     SEEDREAM_EDITING_CALLBACK = 'SEEDREAM_EDITING_CALLBACK',
+    OPENAI_IMAGE_2_CALLBACK = 'OPENAI_IMAGE_2_CALLBACK',
 }

package/helpers/image-generation/calculate-image-generation-price.helper.ts

@@ -1,4 +1,4 @@
-import { ImageGenerationJobParams, ImageGenerationPricingRules } from '../../models';
+import { ImageGenerationPricingRules } from '../../models';
 
 export function calculateImageGenerationPrice({
     basePrice,
@@ -7,7 +7,9 @@ export function calculateImageGenerationPrice({
     rules,
 }: {
     basePrice: number;
-    params: Pick<ImageGenerationJobParams, 'resolution'>;
+    params: {
+        resolution?: string;
+    };
     userHasActiveSubscriptionOrProduct: boolean;
     rules: ImageGenerationPricingRules;
 }): number {

package/helpers/index.ts

@@ -1,2 +1,3 @@
 export * from './image-generation';
 export * from './image-editor';
+export * from './openai-image-2';

package/helpers/openai-image-2/calculate-openai-image-2-price.helper.ts

@@ -0,0 +1,160 @@
+type Image2Quality = 'low' | 'medium' | 'high';
+type Image2Resolution = '1K' | '2K' | '4K';
+type Image2Size = { width: number; height: number };
+
+export type OpenAIImage2PricedModel = {
+    aiModel: string;
+    params?: {
+        quality?: unknown;
+        aspectRatio?: Partial<Record<string, Image2Size | 'auto'>>;
+    };
+};
+
+const LOW_QUALITY_SURCHARGE_STARS = 2;
+const OPENAI_OUTPUT_PRICE_PER_1M_USD = 30;
+const STAR_PRICE_USD = 0.018;
+const TARGET_MARGIN = 0.6;
+const IMAGE_2_INPUT_IMAGE_SURCHARGE_STARS = 2;
+
+const IMAGE_2_QUALITY_BASE_TOKENS: Record<Image2Quality, number> = {
+    low: 16,
+    medium: 48,
+    high: 96,
+};
+
+const IMAGE_2_RESOLUTION_MULTIPLIER: Record<Image2Resolution, number> = {
+    '1K': 1,
+    '2K': 2,
+    '4K': 4,
+};
+
+const IMAGE_2_MAX_EDGE = 3840;
+const IMAGE_2_MAX_PIXEL_BUDGET = 8_294_400;
+const IMAGE_2_SIZE_STEP = 16;
+
+export function isOpenAIImage2Model(model: Pick<OpenAIImage2PricedModel, 'aiModel'>): boolean {
+    return model.aiModel.toLowerCase().startsWith('gpt-image-2');
+}
+
+export function calculateOpenAIImage2InternalPrice(params: {
+    model: OpenAIImage2PricedModel;
+    aspectRatio: string;
+    resolution?: string;
+    hasAttachedImage?: boolean;
+}): number | null {
+    const { model, aspectRatio, resolution, hasAttachedImage = false } = params;
+
+    const quality = resolveQuality(model.aiModel, model.params?.quality);
+    const normalizedResolution = normalizeResolution(resolution);
+    const baseSize = model.params?.aspectRatio?.[aspectRatio];
+    if (!quality || !isImage2Size(baseSize) || !normalizedResolution) {
+        return null;
+    }
+
+    const multiplier = IMAGE_2_RESOLUTION_MULTIPLIER[normalizedResolution];
+    const normalizedSize = normalizeImage2SizeToOpenAILimits({
+        width: Math.round(baseSize.width * multiplier),
+        height: Math.round(baseSize.height * multiplier),
+    });
+    const outputTokens = calculateImage2OutputTokens({
+        quality,
+        ...normalizedSize,
+    });
+
+    const costUsd = (outputTokens / 1_000_000) * OPENAI_OUTPUT_PRICE_PER_1M_USD;
+    const sellUsd = costUsd / (1 - TARGET_MARGIN);
+
+    let finalStars = Math.max(1, Math.ceil(sellUsd / STAR_PRICE_USD));
+    if (hasAttachedImage) {
+        finalStars += IMAGE_2_INPUT_IMAGE_SURCHARGE_STARS;
+    }
+
+    if (quality === 'low') {
+        finalStars += LOW_QUALITY_SURCHARGE_STARS;
+    }
+
+    return finalStars;
+}
+
+function isImage2Size(value: unknown): value is Image2Size {
+    if (!value || typeof value !== 'object') return false;
+    const candidate = value as Partial<Image2Size>;
+    return typeof candidate.width === 'number' && typeof candidate.height === 'number';
+}
+
+function resolveQuality(aiModel: string, rawQuality: unknown): Image2Quality | null {
+    const normalizedModel = aiModel.toLowerCase();
+    if (normalizedModel.endsWith('-low')) return 'low';
+    if (normalizedModel.endsWith('-medium')) return 'medium';
+    if (normalizedModel.endsWith('-high')) return 'high';
+
+    if (typeof rawQuality === 'string') {
+        return normalizeQuality(rawQuality);
+    }
+
+    if (rawQuality && typeof rawQuality === 'object') {
+        const values = Object.values(rawQuality as Record<string, unknown>);
+        for (const value of values) {
+            if (typeof value !== 'string') continue;
+            const normalized = normalizeQuality(value);
+            if (normalized) return normalized;
+        }
+    }
+
+    return null;
+}
+
+function normalizeQuality(value: string): Image2Quality | null {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'low') return 'low';
+    if (normalized === 'medium') return 'medium';
+    if (normalized === 'high') return 'high';
+    return null;
+}
+
+function normalizeResolution(value?: string): Image2Resolution | null {
+    if (!value) return '1K';
+    if (value === '1K' || value === '2K' || value === '4K') {
+        return value;
+    }
+    return null;
+}
+
+function normalizeImage2SizeToOpenAILimits(size: Image2Size): Image2Size {
+    let scale = 1;
+    const longestEdge = Math.max(size.width, size.height);
+    if (longestEdge > IMAGE_2_MAX_EDGE) {
+        scale = Math.min(scale, IMAGE_2_MAX_EDGE / longestEdge);
+    }
+
+    const pixelCount = size.width * size.height;
+    if (pixelCount > IMAGE_2_MAX_PIXEL_BUDGET) {
+        scale = Math.min(scale, Math.sqrt(IMAGE_2_MAX_PIXEL_BUDGET / pixelCount));
+    }
+
+    const normalizedWidth =
+        Math.floor((size.width * scale) / IMAGE_2_SIZE_STEP) * IMAGE_2_SIZE_STEP;
+    const normalizedHeight =
+        Math.floor((size.height * scale) / IMAGE_2_SIZE_STEP) * IMAGE_2_SIZE_STEP;
+
+    return {
+        width: Math.max(IMAGE_2_SIZE_STEP, normalizedWidth),
+        height: Math.max(IMAGE_2_SIZE_STEP, normalizedHeight),
+    };
+}
+
+function calculateImage2OutputTokens(params: {
+    quality: Image2Quality;
+    width: number;
+    height: number;
+}): number {
+    const { quality, width, height } = params;
+    const longestEdge = Math.max(width, height);
+    const shortestEdge = Math.min(width, height);
+    const qualityBaseTokens = IMAGE_2_QUALITY_BASE_TOKENS[quality];
+    const scaledShortEdgeTokens = Math.round((qualityBaseTokens * shortestEdge) / longestEdge);
+    const widthTokens = width >= height ? qualityBaseTokens : scaledShortEdgeTokens;
+    const heightTokens = width >= height ? scaledShortEdgeTokens : qualityBaseTokens;
+
+    return Math.ceil((widthTokens * heightTokens * (2_000_000 + width * height)) / 4_000_000);
+}

package/helpers/openai-image-2/index.ts

@@ -0,0 +1 @@
+export * from './calculate-openai-image-2-price.helper';

package/models/image-editor/image-editor-job-params.schema.ts

@@ -6,6 +6,7 @@ export const ImageEditorJobParamsSchema = z.object({
     imageUrls: z.array(z.string()).optional(),
     systemPromptId: z.string().uuid().optional(),
     aspectRatio: z.string().optional(),
+    resolution: z.string().optional(),
     userHasActiveSubscriptionOrProduct: z.boolean().optional(),
 });
 

package/models/image-editor/image-editor-job-request-params.schema.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 
 export const ImageEditorJobRequestParamsSchema = z.object({
-    imageUrls: z.array(z.string().uuid()).optional().default([]),
+    imageUrls: z.array(z.string().uuid()).min(1),
     systemPromptId: z.string().uuid().optional(),
     aspectRatio: z.string().optional(),
+    resolution: z.string().optional(),
 });
 
 export type ImageEditorJobRequestParams = z.infer<typeof ImageEditorJobRequestParamsSchema>;

package/models/image-editor/image-editor-model-params.schema.ts

@@ -13,6 +13,11 @@ export const ImageEditorModelParamsSchema = z.object({
             height: z.number().int().positive(),
         }),
     ),
+    resolution: z
+        .object({
+            options: z.array(z.string()),
+        })
+        .optional(),
 });
 
 export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/multisite",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "Multisite API contracts (DTO schemas, routes, constants)",
   "type": "commonjs",
   "main": "build/index.js",