@purpleschool/gptbot 0.7.13 → 0.7.15

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { PRESENTATION_STAGE } from '../../../constants';
+import { SlideOutlineSchema } from './slide-outline.schema';
+import { SlideSchema } from './slide.schema';
+
+export const PresentationSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    stage: z.nativeEnum(PRESENTATION_STAGE),
+    title: z.string(),
+    thumbnail: z.string(),
+    languageId: z.string(),
+    templateId: z.string(),
+    downloadUrl: z.string().nullable(),
+    slideCount: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type Presentation = z.infer<typeof PresentationSchema>;
+
+export const PresentationWithSlidesSchema = PresentationSchema.extend({
+    outline: z.array(SlideOutlineSchema),
+    slides: z.array(SlideSchema),
+});
+export type PresentationWithSlides = z.infer<typeof PresentationWithSlidesSchema>;

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

@@ -0,0 +1,13 @@
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../../../constants';
+import { z } from 'zod';
+
+export const SlideContentTypeSchema = z.object({
+    id: z.nativeEnum(SLIDE_CONTENT_TYPE),
+    title: z.string(),
+    layouts: z.array(z.nativeEnum(SLIDE_LAYOUT)),
+    order: z.number(),
+    icon: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type SlideContentType = z.infer<typeof SlideContentTypeSchema>;

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

@@ -0,0 +1,218 @@
+import { z } from 'zod';
+import { SLIDE_CONTENT_TYPE } from '../../../constants';
+
+export enum SLIDE_CHART_TYPE {
+    BAR = 'BAR',
+}
+
+export const ImageSlotSchema = z.object({
+    uuid: z
+        .string()
+        .uuid()
+        .describe('Generate a valid uuid for image slot, that will be used for future lookups'),
+    prompt: z.string().describe('Image prompt for slide'),
+});
+export type ImageSlot = z.infer<typeof ImageSlotSchema>;
+
+export const IconSlotSchema = z.object({
+    uuid: z
+        .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',
+        ),
+});
+export type IconSlot = z.infer<typeof IconSlotSchema>;
+
+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(200),
+    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'),
+    }),
+    date: z.object({
+        label: z.string().describe('Literal "Date" in presentation\'s language'),
+        value: z
+            .string()
+            .describe(
+                'Date of the presentation in the "dd month yyyy" format in presentation\'s locale',
+            ),
+    }),
+    email: z.object({
+        label: z.string().describe('Just default word "Email"'),
+        value: z.string().describe('Just default "email@example.com"'),
+    }),
+});
+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(200),
+    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'),
+    }),
+    date: z.object({
+        label: z.string().describe('Literal "Date" in presentation\'s language'),
+        value: z
+            .string()
+            .describe(
+                'Date of the presentation in the "dd month yyyy" format in presentation\'s locale',
+            ),
+    }),
+    email: z.object({
+        label: z.string().describe('Just default word "Email"'),
+        value: z.string().describe('Just default "email@example.com"'),
+    }),
+});
+export type ThankYouSlideData = z.infer<typeof ThankYouSlideDataSchema>;
+
+export const StructuredListSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.STRUCTURED_LIST),
+    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),
+    list: z
+        .array(
+            z.object({
+                title: z.string().describe('List item title in about 6 words').min(10).max(200),
+                description: z
+                    .string()
+                    .describe('List item description in about 6 words')
+                    .min(10)
+                    .max(200),
+            }),
+        )
+        .min(4)
+        .max(4),
+});
+export type StructuredListSlideData = z.infer<typeof StructuredListSlideDataSchema>;
+
+export const TextSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
+    description: z
+        .string()
+        .describe(
+            'Fairly long textual description of the point presented in the title. A couple of paragraphs.',
+        )
+        .min(300)
+        .max(1000),
+});
+export type TextSlideData = z.infer<typeof TextSlideDataSchema>;
+
+export const ContentsSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CONTENTS),
+    title: z
+        .string()
+        .describe(
+            'This slide represents table of contents for the presentation and must be named "Contents" in the presentation language',
+        )
+        .min(10)
+        .max(200),
+    items: z
+        .array(z.string().min(1))
+        .min(1)
+        .describe(
+            'List of slide titles. Must be relevant and generated after all the slides are generated',
+        ),
+});
+export type ContentsSlideData = z.infer<typeof ContentsSlideDataSchema>;
+
+export const ImageSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.IMAGE),
+    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),
+    imageSlot: ImageSlotSchema,
+});
+export type ImageSlideData = z.infer<typeof ImageSlideDataSchema>;
+
+export const SectionBreakSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.SECTION_BREAK),
+    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),
+});
+export type SectionBreakSlideData = z.infer<typeof SectionBreakSlideDataSchema>;
+
+export const TableSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TABLE),
+    title: z
+        .string()
+        .describe('Slide title and table title at the same time in a couple of words')
+        .min(10)
+        .max(200),
+    description: z.string().describe('Description of the table represents').min(10).max(200),
+    table: z.object({
+        columnHeaders: z
+            .array(z.string().min(1).max(50))
+            .min(1)
+            .max(10)
+            .describe('Array of column header labels'),
+        rows: z
+            .array(z.array(z.string().min(1).max(150)))
+            .min(2)
+            .max(10)
+            .describe(
+                'Table rows; each row must have exactly the same number of cells as columnHeaders',
+            ),
+        hasRowHeaders: z.boolean().describe('If table needs special row headers, set this to true'),
+        hasSummaryRow: z.boolean().describe('If table needs a summary row, set this to true'),
+    }),
+});
+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))
+        .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'),
+                data: z.array(z.number()).describe('Values corresponding to categories'),
+                type: z
+                    .number()
+                    .min(0)
+                    .max(11)
+                    .describe('Series type. Used to discriminate colors when applying theme'),
+            }),
+        )
+        .min(1)
+        .max(12)
+        .describe('Data series for the chart'),
+    yAxisLabel: z.string().max(40).optional().describe('Y-axis label'),
+    unit: z.string().max(10).optional().describe('Unit symbol (%, $, etc.)'),
+});
+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('Description of the slide in about 6 words').min(10).max(200),
+    chart: z.discriminatedUnion('type', [BarChartSlideDataSchema]),
+});
+export type ChartSlideData = z.infer<typeof ChartSlideDataSchema>;
+
+export const SlideContentSchema = z.discriminatedUnion('contentType', [
+    CoverSlideDataSchema,
+    StructuredListSlideDataSchema,
+    TextSlideDataSchema,
+    ContentsSlideDataSchema,
+    SectionBreakSlideDataSchema,
+    ImageSlideDataSchema,
+    ThankYouSlideDataSchema,
+    TableSlideDataSchema,
+    ChartSlideDataSchema,
+]);
+export type SlideContent = z.infer<typeof SlideContentSchema>;

package/models/tools/presentation/slide-icon-slot.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { SLIDE_ICON_SLOT_STATUS } from '../../../constants';
+
+export const SlideIconSlotSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    alt: z.string(),
+    url: z.string().nullable(),
+    slideId: z.string(),
+    status: z.nativeEnum(SLIDE_ICON_SLOT_STATUS),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/tools/presentation/slide-image-slot.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SLIDE_IMAGE_SLOT_STATUS } from '../../../constants';
+
+export const SlideImageSlotSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    alt: z.string(),
+    url: z.string().nullable(),
+    placeholder: z.string(),
+    slideId: z.string(),
+    status: z.nativeEnum(SLIDE_IMAGE_SLOT_STATUS),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { SLIDE_CONTENT_TYPE } from '../../../constants';
+
+export const SlideOutlineSchema = z.object({
+    uuid: z.string(),
+    order: z.number(),
+    title: z.string().max(80),
+    body: z.string().max(500),
+    contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+    presentationId: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type SlideOutline = z.infer<typeof SlideOutlineSchema>;
+
+export const SlideOutlineUpdateSchema = SlideOutlineSchema.pick({
+    title: true,
+    body: true,
+    contentTypeId: true,
+}).partial();
+export type SlideOutlineUpdate = z.infer<typeof SlideOutlineUpdateSchema>;
+
+export const SlideOutlineBulkUpdateSchema = SlideOutlineSchema.pick({
+    order: true,
+    title: true,
+    body: true,
+    contentTypeId: true,
+    presentationId: true,
+})
+    .extend({
+        uuid: z.string().uuid().optional(),
+    })
+    .array()
+    .min(1, 'Must include at least one slide outline')
+    .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 slide outlines must belong to the same presentation',
+            path: ['presentationId'],
+        },
+    );
+export type SlideOutlineBulkUpdate = z.infer<typeof SlideOutlineBulkUpdateSchema>;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+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';
+
+export const SlideSchema = z.object({
+    uuid: z.string().uuid(),
+    order: z.number(),
+    contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+    layoutId: z.nativeEnum(SLIDE_LAYOUT),
+    content: SlideContentSchema,
+    presentationId: z.string(),
+    iconSlots: z.array(SlideIconSlotSchema),
+    imageSlots: z.array(SlideImageSlotSchema),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type Slide = z.infer<typeof SlideSchema>;

package/package.json

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