@purpleschool/gptbot 0.7.80 → 0.7.82

package/constants/presentation/enums/presentation-ai-action-pricing-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_PRICING_TYPE {
+    PER_CHARACTER = 'PER_CHARACTER',
+    FLAT = 'FLAT',
+}

package/constants/presentation/enums/presentation-ai-action-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_TYPE {
+    PARAPHRASE = 'PARAPHRASE',
+    GENERATE_REPORT = 'GENERATE_REPORT',
+}

package/constants/presentation/enums/slide-image-slot-action.enum.ts

@@ -0,0 +1,4 @@
+export enum SLIDE_IMAGE_SLOT_ACTION {
+    REPLACE = 'REPLACE',
+    GENERATE = 'GENERATE',
+}

package/helpers/index.ts

@@ -1,4 +1,5 @@
 export * from './ai-model';
+export * from './presentation';
 export * from './stt';
 export * from './subscription';
 export * from './tts';

package/helpers/presentation/calculate-presentation-ai-action-price.util.ts

@@ -0,0 +1,20 @@
+import { PRESENTATION_AI_ACTION_PRICING_TYPE } from '../../constants';
+import { PresentationAiActionPricingRules } from '../../models/tools/presentation';
+
+export function calculatePresentationAiActionPrice(
+    pricingRules: PresentationAiActionPricingRules,
+    selectionText: string,
+): number {
+    switch (pricingRules.type) {
+        case PRESENTATION_AI_ACTION_PRICING_TYPE.PER_CHARACTER:
+            const characterCount = selectionText.length;
+            const price = characterCount * pricingRules.price;
+            return Math.max(1, Math.ceil(price));
+
+        case PRESENTATION_AI_ACTION_PRICING_TYPE.FLAT:
+            return Math.max(1, Math.ceil(pricingRules.price));
+
+        default:
+            throw new Error(`Unknown pricing type`);
+    }
+}

package/helpers/presentation/index.ts

@@ -0,0 +1 @@
+export * from './calculate-presentation-ai-action-price.util';

package/models/tools/index.ts

@@ -1,5 +1,6 @@
 export * from './language';
 export * from './paraphrase';
+export * from './presentation';
 export * from './stt';
 export * from './tts';
 export * from './video';

package/models/tools/presentation/index.ts

@@ -5,3 +5,4 @@ export * from './slide-outline.schema';
 export * from './slide.schema';
 export * from './slide-content.schema';
 export * from './presentation-config.schema';
+export * from './presentation-ai-action.schema';

package/models/tools/presentation/presentation-ai-action.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import {
+    PRESENTATION_AI_ACTION_PRICING_TYPE,
+    PRESENTATION_AI_ACTION_TYPE,
+} from '../../../constants';
+
+export const PresentationAiActionPricingRulesSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(PRESENTATION_AI_ACTION_PRICING_TYPE.PER_CHARACTER),
+        price: z.number(),
+    }),
+    z.object({
+        type: z.literal(PRESENTATION_AI_ACTION_PRICING_TYPE.FLAT),
+        price: z.number(),
+    }),
+]);
+export type PresentationAiActionPricingRules = z.infer<
+    typeof PresentationAiActionPricingRulesSchema
+>;
+
+export const PresentationAiActionSchema = z.object({
+    uuid: z.string(),
+    type: z.nativeEnum(PRESENTATION_AI_ACTION_TYPE),
+    pricingRules: PresentationAiActionPricingRulesSchema,
+    maxPromptLength: z.number(),
+    aiModel: z.string(),
+    title: z.string(),
+    icon: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type PresentationAiAction = z.infer<typeof PresentationAiActionSchema>;

package/models/tools/presentation/presentation-config.schema.ts

@@ -2,16 +2,19 @@ import { z } from 'zod';
 import { SlideContentTypeSchema } from './slide-content-type.schema';
 import { LanguageSchema } from '../language';
 import { PresentationTemplateSchema } from './presentation-template.schema';
+import { PresentationAiActionSchema } from './presentation-ai-action.schema';
 
 export const PresentationConfigSchema = z.object({
     slideContentTypes: z.array(SlideContentTypeSchema),
     languages: z.array(LanguageSchema),
     templates: z.array(PresentationTemplateSchema),
+    aiActions: z.array(PresentationAiActionSchema),
     slideGenerationPrice: z.number(),
     maxSlides: z.number(),
     minSlides: z.number(),
     maxSlideTitleLength: z.number(),
     maxSlideOutlineLength: z.number(),
     maxPromptLength: z.number(),
+    imageGenerationPrice: z.number(),
 });
 export type PresentationConfig = z.infer<typeof PresentationConfigSchema>;

package/models/tools/presentation/presentation.schema.ts

@@ -13,6 +13,8 @@ export const PresentationSchema = z.object({
     templateId: z.string(),
     downloadUrl: z.string().nullable(),
     slideCount: z.number(),
+    lastContentUpdateAt: z.date().nullable(),
+    lastPptxExportedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/tools/presentation/slide-content-edit.schema.ts

@@ -0,0 +1,154 @@
+import z from 'zod';
+import {
+    ICoverSlideDataStructure,
+    IThankYouSlideDataStructure,
+    ITextSlideDataStructure,
+    IStructuredListSlideDataStructure,
+    IContentsSlideDataStructure,
+    IImageSlideDataStructure,
+    ISectionBreakSlideDataStructure,
+    ITableSlideDataStructure,
+    SLIDE_CHART_TYPE,
+    IBarChartSlideDataStructure,
+    IChartSlideDataStructure,
+    ImageSlotSchema,
+} from './slide-content.schema';
+import { SLIDE_CONTENT_TYPE } from '../../../constants';
+
+export const CoverSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.COVER),
+    title: z.string().max(1000),
+    author: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    date: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    email: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ICoverSlideDataStructure>;
+
+export const ThankYouSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.THANK_YOU),
+    title: z.string().max(1000),
+    author: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    date: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    email: z.object({
+        label: z.string().max(200),
+        value: z.string().max(500),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<IThankYouSlideDataStructure>;
+
+export const TextSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT),
+    title: z.string().max(1000),
+    description: z.string().max(5000),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITextSlideDataStructure>;
+
+export const StructuredListSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.STRUCTURED_LIST),
+    title: z.string().max(1000),
+    description: z.string().max(2000),
+    list: z
+        .array(
+            z.object({
+                title: z.string().max(500),
+                description: z.string().max(1000),
+            }),
+        )
+        .max(15),
+    version: z.literal(1),
+}) satisfies z.ZodType<IStructuredListSlideDataStructure>;
+
+export const ContentsSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CONTENTS),
+    title: z.string().max(1000),
+    items: z
+        .array(
+            z.object({
+                pageNumber: z.number(),
+                title: z.string().max(1000),
+            }),
+        )
+        .max(100),
+    version: z.literal(1),
+}) satisfies z.ZodType<IContentsSlideDataStructure>;
+
+export const ImageSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT_WITH_IMAGE),
+    title: z.string().max(1000),
+    description: z.string().max(4000),
+    imageSlot: ImageSlotSchema,
+    version: z.literal(1),
+}) satisfies z.ZodType<IImageSlideDataStructure>;
+
+export const SectionBreakSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.SECTION_BREAK),
+    title: z.string().max(1000),
+    description: z.string().max(1000),
+    version: z.literal(1),
+}) satisfies z.ZodType<ISectionBreakSlideDataStructure>;
+
+export const TableSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TABLE),
+    title: z.string().max(1000),
+    description: z.string().max(2000),
+    table: z.object({
+        columnHeaders: z.array(z.string().max(500)).max(30),
+        rows: z.array(z.array(z.string().max(1000))).max(50),
+        hasRowHeaders: z.boolean(),
+        hasSummaryRow: z.boolean(),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITableSlideDataStructure>;
+
+export const BarChartSlideDataUserEditSchema = z.object({
+    type: z.literal(SLIDE_CHART_TYPE.BAR),
+    categories: z.array(z.string().max(500)).max(100),
+    series: z
+        .array(
+            z.object({
+                name: z.string().max(500),
+                data: z.array(z.number()),
+                type: z.number().min(0).max(11),
+            }),
+        )
+        .max(10),
+    yAxisLabel: z.string().max(500).optional(),
+    unit: z.string().max(100).optional(),
+    version: z.literal(1),
+}) satisfies z.ZodType<IBarChartSlideDataStructure>;
+
+export const ChartSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CHART),
+    title: z.string().max(1000),
+    description: z.string().max(4000),
+    chart: z.discriminatedUnion('type', [BarChartSlideDataUserEditSchema]),
+    version: z.literal(1),
+}) satisfies z.ZodType<IChartSlideDataStructure>;
+
+export const SlideContentUserEditSchema = z.discriminatedUnion('contentType', [
+    CoverSlideDataUserEditSchema,
+    StructuredListSlideDataUserEditSchema,
+    TextSlideDataUserEditSchema,
+    ContentsSlideDataUserEditSchema,
+    SectionBreakSlideDataUserEditSchema,
+    ImageSlideDataUserEditSchema,
+    ThankYouSlideDataUserEditSchema,
+    TableSlideDataUserEditSchema,
+    ChartSlideDataUserEditSchema,
+]);
+export type SlideContentUserEdit = z.infer<typeof SlideContentUserEditSchema>;

package/models/tools/presentation/slide-content.schema.ts

@@ -19,14 +19,95 @@ export const IconSlotSchema = z.object({
         .string()
         .uuid()
         .describe('Generate a valid uuid for icon slot, that will be used for future lookups'),
-    prompt: z
-        .string()
-        .describe(
-            'Icons are stored locally. Provide a search query for a fitting icon. MUST BE IN ENGLISH',
-        ),
+    prompt: z.string().describe('Provide a search query for an fitting icon. MUST BE IN ENGLISH'),
 });
 export type IconSlot = z.infer<typeof IconSlotSchema>;
 
+export interface ICoverSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.COVER;
+    title: string;
+    author: { label: string; value: string };
+    date: { label: string; value: string };
+    email: { label: string; value: string };
+    version: 1;
+}
+
+export interface IThankYouSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.THANK_YOU;
+    title: string;
+    author: { label: string; value: string };
+    date: { label: string; value: string };
+    email: { label: string; value: string };
+    version: 1;
+}
+
+export interface ITextSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.TEXT;
+    title: string;
+    description: string;
+    version: 1;
+}
+
+export interface IStructuredListSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.STRUCTURED_LIST;
+    title: string;
+    description: string;
+    list: Array<{ title: string; description: string }>;
+    version: 1;
+}
+
+export interface IContentsSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.CONTENTS;
+    title: string;
+    items: Array<{ pageNumber: number; title: string }>;
+    version: 1;
+}
+
+export interface IImageSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.TEXT_WITH_IMAGE;
+    title: string;
+    description: string;
+    imageSlot?: ImageSlot;
+    version: 1;
+}
+
+export interface ISectionBreakSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.SECTION_BREAK;
+    title: string;
+    description: string;
+    version: 1;
+}
+
+export interface ITableSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.TABLE;
+    title: string;
+    description: string;
+    table: {
+        columnHeaders: string[];
+        rows: string[][];
+        hasRowHeaders: boolean;
+        hasSummaryRow: boolean;
+    };
+    version: 1;
+}
+
+export interface IBarChartSlideDataStructure {
+    type: SLIDE_CHART_TYPE.BAR;
+    categories: string[];
+    series: Array<{ name: string; data: number[]; type: number }>;
+    yAxisLabel?: string;
+    unit?: string;
+    version: 1;
+}
+
+export interface IChartSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.CHART;
+    title: string;
+    description: string;
+    chart: IBarChartSlideDataStructure;
+    version: 1;
+}
+
 export const CoverSlideDataSchema = z.object({
     contentType: z.literal(SLIDE_CONTENT_TYPE.COVER),
     title: z.string().describe('Slide title in about 6 words').min(10).max(150),
@@ -49,20 +130,22 @@ export const CoverSlideDataSchema = z.object({
         value: z.string().describe('Just default "email@example.com"'),
     }),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<ICoverSlideDataStructure>;
 export type CoverSlideData = z.infer<typeof CoverSlideDataSchema>;
 
 export const ThankYouSlideDataSchema = z.object({
     contentType: z.literal(SLIDE_CONTENT_TYPE.THANK_YOU),
-    title: z.string().describe('Slide title in about 6 words').min(10).max(150),
+    title: z
+        .string()
+        .describe('"Thank you for your attention" in presentation\'s language')
+        .min(10)
+        .max(150),
     author: z.object({
-        label: z.string().describe('Literal "Author" in presentation\'s language'),
-        value: z
-            .string()
-            .describe('Literal "Author of the presentation" in presentation\'s language'),
+        label: z.string().describe('"Author" in presentation\'s language'),
+        value: z.string().describe('"Author of the presentation" in presentation\'s language'),
     }),
     date: z.object({
-        label: z.string().describe('Literal "Date" in presentation\'s language'),
+        label: z.string().describe('"Date" in presentation\'s language'),
         value: z
             .string()
             .describe(
@@ -74,7 +157,7 @@ export const ThankYouSlideDataSchema = z.object({
         value: z.string().describe('Just default "email@example.com"'),
     }),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<IThankYouSlideDataStructure>;
 export type ThankYouSlideData = z.infer<typeof ThankYouSlideDataSchema>;
 
 export const StructuredListSlideDataSchema = z.object({
@@ -90,7 +173,7 @@ export const StructuredListSlideDataSchema = z.object({
         )
         .length(4),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<IStructuredListSlideDataStructure>;
 export type StructuredListSlideData = z.infer<typeof StructuredListSlideDataSchema>;
 
 export const TextSlideDataSchema = z.object({
@@ -99,12 +182,12 @@ export const TextSlideDataSchema = z.object({
     description: z
         .string()
         .describe(
-            'Fairly long textual description of the point presented in the title. A couple of paragraphs.',
+            "Fairly long textual description of the point presented in the title. A couple of paragraphs. Consider maximum amount of text to be 600 characters. Don't cut the text short.",
         )
         .min(300)
-        .max(500),
+        .max(600),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<ITextSlideDataStructure>;
 export type TextSlideData = z.infer<typeof TextSlideDataSchema>;
 
 export const ContentsSlideDataSchema = z.object({
@@ -128,7 +211,7 @@ export const ContentsSlideDataSchema = z.object({
             'List of slide titles. Must be relevant and generated after all the slides are generated',
         ),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<IContentsSlideDataStructure>;
 export type ContentsSlideData = z.infer<typeof ContentsSlideDataSchema>;
 
 export const ImageSlideDataSchema = z
@@ -143,7 +226,9 @@ export const ImageSlideDataSchema = z
         imageSlot: ImageSlotSchema,
         version: z.literal(1),
     })
-    .describe('Slide that contains a title, description of the title');
+    .describe(
+        'Slide that contains a title, description of the title',
+    ) satisfies z.ZodType<IImageSlideDataStructure>;
 export type ImageSlideData = z.infer<typeof ImageSlideDataSchema>;
 
 export const SectionBreakSlideDataSchema = z.object({
@@ -151,7 +236,7 @@ export const SectionBreakSlideDataSchema = z.object({
     title: z.string().describe('Slide title in about 6 words').min(10).max(200),
     description: z.string().describe('Description of the slide in about 6 words').min(10).max(200),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<ISectionBreakSlideDataStructure>;
 export type SectionBreakSlideData = z.infer<typeof SectionBreakSlideDataSchema>;
 
 export const TableSlideDataSchema = z.object({
@@ -169,9 +254,9 @@ export const TableSlideDataSchema = z.object({
             .max(10)
             .describe('Array of column header labels'),
         rows: z
-            .array(z.array(z.string().min(1).max(150)))
-            .min(2)
-            .max(10)
+            .array(z.array(z.string().min(1).max(75)))
+            .min(3)
+            .max(4)
             .describe(
                 'Table rows; each row must have exactly the same number of cells as columnHeaders',
             ),
@@ -179,21 +264,23 @@ export const TableSlideDataSchema = z.object({
         hasSummaryRow: z.boolean().describe('If table needs a summary row, set this to true'),
     }),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<ITableSlideDataStructure>;
 export type TableSlideData = z.infer<typeof TableSlideDataSchema>;
 
 // Charts
 export const BarChartSlideDataSchema = z.object({
     type: z.literal(SLIDE_CHART_TYPE.BAR),
     categories: z
-        .array(z.string().min(1).max(12))
+        .array(z.string())
         .min(1)
         .max(12)
         .describe('Category labels (e.g., months, products, regions)'),
     series: z
         .array(
             z.object({
-                name: z.string().min(1).max(12).describe('Series name for legend'),
+                name: z
+                    .string()
+                    .describe('Series name for legend. Try to include measurements if needed'),
                 data: z.array(z.number()).describe('Values corresponding to categories'),
                 type: z
                     .number()
@@ -203,21 +290,21 @@ export const BarChartSlideDataSchema = z.object({
             }),
         )
         .min(1)
-        .max(12)
-        .describe('Data series for the chart'),
+        .max(1)
+        .describe('Data series for the chart. Only one series is supported'),
     yAxisLabel: z.string().max(40).optional().describe('Y-axis label'),
     unit: z.string().max(10).optional().describe('Unit symbol (%, $, etc.)'),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<IBarChartSlideDataStructure>;
 export type BarChartSlideData = z.infer<typeof BarChartSlideDataSchema>;
 
 export const ChartSlideDataSchema = z.object({
     contentType: z.literal(SLIDE_CONTENT_TYPE.CHART),
-    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
-    description: z.string().describe("Information on slide's topic").min(10).max(400),
+    title: z.string().describe('Slide title in about 2-6 words').max(100),
+    description: z.string().describe("Information on slide's topic").max(600),
     chart: z.discriminatedUnion('type', [BarChartSlideDataSchema]),
     version: z.literal(1),
-});
+}) satisfies z.ZodType<IChartSlideDataStructure>;
 export type ChartSlideData = z.infer<typeof ChartSlideDataSchema>;
 
 export const SlideContentSchema = z.discriminatedUnion('contentType', [

package/models/tools/presentation/slide.schema.ts

@@ -3,6 +3,7 @@ import { SlideContentSchema } from './slide-content.schema';
 import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../../../constants';
 import { SlideIconSlotSchema } from './slide-icon-slot.schema';
 import { SlideImageSlotSchema } from './slide-image-slot.schema';
+import { SlideContentUserEditSchema } from './slide-content-edit.schema';
 
 export const SlideSchema = z.object({
     uuid: z.string().uuid(),
@@ -17,3 +18,49 @@ export const SlideSchema = z.object({
     updatedAt: z.date(),
 });
 export type Slide = z.infer<typeof SlideSchema>;
+
+export const SlideUpdateSchema = SlideSchema.pick({
+    layoutId: true,
+})
+    .extend({
+        content: SlideContentUserEditSchema,
+    })
+    .partial();
+export type SlideUpdate = z.infer<typeof SlideUpdateSchema>;
+
+export const SlideBulkUpdateSchema = SlideSchema.pick({
+    order: true,
+    contentTypeId: true,
+    layoutId: true,
+    presentationId: true,
+})
+    .extend({
+        uuid: z.string().uuid().optional(),
+        content: SlideContentUserEditSchema,
+    })
+    .array()
+    .min(1, 'Must include at least one slide')
+    .refine(
+        (arr) => {
+            const orders = arr.map((s) => s.order);
+            const unique = new Set(orders);
+            if (unique.size !== orders.length) return false;
+            const sorted = [...orders].sort((a, b) => a - b);
+            return sorted.every((val, idx) => val === idx);
+        },
+        {
+            message: 'Slide orders must be unique and sequential starting at 0',
+            path: ['order'],
+        },
+    )
+    .refine(
+        (arr) => {
+            const [firstId, ...rest] = arr.map((s) => s.presentationId);
+            return rest.every((id) => id === firstId);
+        },
+        {
+            message: 'All slides must belong to the same presentation',
+            path: ['presentationId'],
+        },
+    );
+export type SlideBulkUpdate = z.infer<typeof SlideBulkUpdateSchema>;

package/models/user-to-subscription.schema.ts

@@ -25,3 +25,10 @@ export const UserToSubscriptionWithSubscriptionSchema = z.intersection(
         subscription: SubscriptionSchema,
     }),
 );
+
+export const UserToSubscriptionWithDowngradeSubscriptionSchema = z.intersection(
+    UserToSubscriptionWithSubscriptionSchema,
+    z.object({
+        subscriptionDowngrade: SubscriptionSchema.optional(),
+    }),
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.7.80",
+  "version": "0.7.82",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",