@purpleschool/gptbot-tools 0.0.32 → 0.0.34

package/build/video/commands/video.command.js

@@ -4,6 +4,7 @@ exports.VideoCommand = void 0;
 const zod_1 = require("zod");
 const command_response_schema_1 = require("../../common/models/command-response.schema");
 const video_job_schema_1 = require("../models/video-job.schema");
+const models_1 = require("../models");
 var VideoCommand;
 (function (VideoCommand) {
     VideoCommand.RequestSchema = zod_1.z.object({
@@ -12,12 +13,7 @@ var VideoCommand;
         prompt: zod_1.z.string(),
         userBalance: zod_1.z.number(),
         modelId: zod_1.z.string(),
-        params: zod_1.z.object({
-            imageUrls: zod_1.z.string().array().optional(),
-            duration: zod_1.z.number(),
-            aspectRatio: zod_1.z.string().optional(),
-            quality: zod_1.z.string().optional(),
-        }),
+        params: models_1.VideoGenerationRequestParamsSchema,
     });
     VideoCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(video_job_schema_1.VideoJobSchema);
 })(VideoCommand || (exports.VideoCommand = VideoCommand = {}));

package/build/video/enums/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./veo-aspect-ratio.enum"), exports);
 __exportStar(require("./veo-person-allow.enum"), exports);
 __exportStar(require("./veo-job-params-type.enum"), exports);
 __exportStar(require("./video-resolution.enum"), exports);
+__exportStar(require("./video-pricing-rule-type.enum"), exports);

package/build/video/enums/video-pricing-rule-type.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIDEO_PRICING_RULE_TYPE = void 0;
+var VIDEO_PRICING_RULE_TYPE;
+(function (VIDEO_PRICING_RULE_TYPE) {
+    VIDEO_PRICING_RULE_TYPE["FLAT"] = "flat";
+})(VIDEO_PRICING_RULE_TYPE || (exports.VIDEO_PRICING_RULE_TYPE = VIDEO_PRICING_RULE_TYPE = {}));

package/build/video/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./enums"), exports);
 __exportStar(require("./models"), exports);
 __exportStar(require("./queries"), exports);
 __exportStar(require("./routes"), exports);
+__exportStar(require("./utils"), exports);

package/build/video/models/video-model.schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VideoModelSchema = exports.VideoModelParamsSchema = void 0;
+exports.VideoModelSchema = exports.VideoModelPricingRulesSchema = exports.VideoModelPricingRuleConditionSchema = exports.VideoGenerationRequestParamsSchema = exports.VideoModelParamsSchema = void 0;
 const zod_1 = require("zod");
 const common_1 = require("../../common");
 const enums_1 = require("../enums");
@@ -19,6 +19,20 @@ exports.VideoModelParamsSchema = zod_1.z.object({
         .optional(),
     quality: zod_1.z.string().optional(),
 });
+exports.VideoGenerationRequestParamsSchema = zod_1.z.object({
+    imageUrls: zod_1.z.string().array().optional(),
+    duration: zod_1.z.number(),
+    aspectRatio: zod_1.z.string().optional(),
+    quality: zod_1.z.string().optional(),
+});
+exports.VideoModelPricingRuleConditionSchema = zod_1.z.object({
+    aspectRatio: zod_1.z.string(),
+});
+exports.VideoModelPricingRulesSchema = zod_1.z.array(zod_1.z.object({
+    type: zod_1.z.nativeEnum(enums_1.VIDEO_PRICING_RULE_TYPE),
+    condition: exports.VideoModelPricingRuleConditionSchema,
+    value: zod_1.z.number(),
+}));
 exports.VideoModelSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     title: zod_1.z.string(),
@@ -30,6 +44,7 @@ exports.VideoModelSchema = zod_1.z.object({
     strategy: zod_1.z.nativeEnum(enums_1.VIDEO_GENERATION_STRATEGY),
     maxInputLength: zod_1.z.number(),
     params: exports.VideoModelParamsSchema,
+    pricingRules: exports.VideoModelPricingRulesSchema,
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/video/utils/calculate-video-generation-price.util.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateVideoGenerationPrice = calculateVideoGenerationPrice;
+const enums_1 = require("../enums");
+function matchesCondition(condition, params) {
+    const keys = Object.keys(condition);
+    return keys.every((key) => {
+        const expected = condition[key];
+        if (expected === undefined || expected === null || expected === '') {
+            return true;
+        }
+        const value = params[key];
+        if (value === undefined || value === null) {
+            return false;
+        }
+        return value === expected;
+    });
+}
+function calculateVideoGenerationPrice({ pricePerSecond, params, rules, }) {
+    const base = pricePerSecond * params.duration;
+    const flatMarkup = rules.reduce((sum, r) => {
+        if (r.type !== enums_1.VIDEO_PRICING_RULE_TYPE.FLAT) {
+            return sum;
+        }
+        return matchesCondition(r.condition, params) ? sum + r.value : sum;
+    }, 0);
+    return Math.ceil(base + flatMarkup);
+}

package/build/video/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculate-video-generation-price.util"), exports);
+__exportStar(require("./calculate-video-generation-price.util"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

package/video/commands/video.command.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { VideoJobSchema } from '../models/video-job.schema';
+import { VideoGenerationRequestParamsSchema } from '../models';
 
 export namespace VideoCommand {
     export const RequestSchema = z.object({
@@ -9,12 +10,7 @@ export namespace VideoCommand {
         prompt: z.string(),
         userBalance: z.number(),
         modelId: z.string(),
-        params: z.object({
-            imageUrls: z.string().array().optional(),
-            duration: z.number(),
-            aspectRatio: z.string().optional(),
-            quality: z.string().optional(),
-        }),
+        params: VideoGenerationRequestParamsSchema,
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video/enums/index.ts

@@ -6,3 +6,4 @@ export * from './veo-aspect-ratio.enum';
 export * from './veo-person-allow.enum';
 export * from './veo-job-params-type.enum';
 export * from './video-resolution.enum';
+export * from './video-pricing-rule-type.enum';

package/video/enums/video-pricing-rule-type.enum.ts

@@ -0,0 +1,3 @@
+export enum VIDEO_PRICING_RULE_TYPE {
+    FLAT = 'flat',
+}

package/video/index.ts

@@ -3,3 +3,4 @@ export * from './enums';
 export * from './models';
 export * from './queries';
 export * from './routes';
+export * from './utils';

package/video/models/video-model.schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { IconVariantsSchema } from '../../common';
-import { VIDEO_GENERATION_STRATEGY } from '../enums';
+import { VIDEO_GENERATION_STRATEGY, VIDEO_PRICING_RULE_TYPE } from '../enums';
 
 export const VideoModelParamsSchema = z.object({
     imageAttachment: z.object({
@@ -20,6 +20,28 @@ export const VideoModelParamsSchema = z.object({
 
 export type VideoModelParams = z.infer<typeof VideoModelParamsSchema>;
 
+export const VideoGenerationRequestParamsSchema = z.object({
+    imageUrls: z.string().array().optional(),
+    duration: z.number(),
+    aspectRatio: z.string().optional(),
+    quality: z.string().optional(),
+});
+export type VideoGenerationRequestParams = z.infer<typeof VideoGenerationRequestParamsSchema>;
+
+export const VideoModelPricingRuleConditionSchema = z.object({
+    aspectRatio: z.string(),
+});
+export type VideoModelPricingRuleCondition = z.infer<typeof VideoModelPricingRuleConditionSchema>;
+
+export const VideoModelPricingRulesSchema = z.array(
+    z.object({
+        type: z.nativeEnum(VIDEO_PRICING_RULE_TYPE),
+        condition: VideoModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type VideoModelPricingRules = z.infer<typeof VideoModelPricingRulesSchema>;
+
 export const VideoModelSchema = z.object({
     uuid: z.string(),
     title: z.string(),
@@ -31,6 +53,7 @@ export const VideoModelSchema = z.object({
     strategy: z.nativeEnum(VIDEO_GENERATION_STRATEGY),
     maxInputLength: z.number(),
     params: VideoModelParamsSchema,
+    pricingRules: VideoModelPricingRulesSchema,
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/video/utils/calculate-video-generation-price.util.ts

@@ -0,0 +1,50 @@
+import { VIDEO_PRICING_RULE_TYPE } from '../enums';
+import {
+    VideoGenerationRequestParams,
+    VideoModelPricingRuleCondition,
+    VideoModelPricingRules,
+} from '../models';
+
+function matchesCondition(
+    condition: VideoModelPricingRuleCondition,
+    params: VideoGenerationRequestParams,
+): boolean {
+    const keys = Object.keys(condition) as (keyof VideoModelPricingRuleCondition)[];
+
+    return keys.every((key) => {
+        const expected = condition[key];
+
+        if (expected === undefined || expected === null || expected === '') {
+            return true;
+        }
+
+        const value = params[key];
+        if (value === undefined || value === null) {
+            return false;
+        }
+
+        return value === expected;
+    });
+}
+
+export function calculateVideoGenerationPrice({
+    pricePerSecond,
+    params,
+    rules,
+}: {
+    pricePerSecond: number;
+    params: VideoGenerationRequestParams;
+    rules: VideoModelPricingRules;
+}) {
+    const base = pricePerSecond * params.duration;
+
+    const flatMarkup = rules.reduce((sum, r) => {
+        if (r.type !== VIDEO_PRICING_RULE_TYPE.FLAT) {
+            return sum;
+        }
+
+        return matchesCondition(r.condition, params) ? sum + r.value : sum;
+    }, 0);
+
+    return Math.ceil(base + flatMarkup);
+}

package/video/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './calculate-video-generation-price.util';
+export * from './calculate-video-generation-price.util';