@purpleschool/multisite 0.0.34 → 0.0.41

package/models/text-chat/index.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import {
+    FILE_TYPE,
+    TEXT_CHAT_ERROR_CODE,
+    TEXT_CHAT_MESSAGE_ROLE,
+    TEXT_CHAT_MESSAGE_STATUS,
+    TOOL_MODEL_STATUS,
+} from '../../constants';
+import { FileSchema } from '../file.schema';
+import { UnlockedBySchema } from '../unlocked-by-subscription.schema';
+
+export * from './stream.schema';
+export * from './provider-config.schema';
+export * from './category.schema';
+
+const CountSchema = z.number().int().safe().nonnegative();
+const TimestampSchema = z.string().datetime().or(z.date());
+
+export const TextChatFileSchema = FileSchema.extend({
+    type: z.enum([FILE_TYPE.IMAGE, FILE_TYPE.TEXT, FILE_TYPE.DOCUMENT]),
+    contentLength: CountSchema.nullable(),
+});
+export type TextChatFile = z.infer<typeof TextChatFileSchema>;
+
+export const TextChatModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    model: z.string(),
+    description: z.string(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    canUse: z.boolean(),
+    unlockedBy: UnlockedBySchema.nullable(),
+    supportsImageAttachment: z.boolean(),
+    maxPromptLength: CountSchema.positive(),
+    maxContextCharacters: CountSchema.positive(),
+    order: z.number().int(),
+});
+export type TextChatModel = z.infer<typeof TextChatModelSchema>;
+
+export const TextChatConfigSchema = z.object({
+    models: z.array(TextChatModelSchema),
+    maxFileAttachments: CountSchema.positive(),
+    maxImageUploadSize: CountSchema.positive(),
+    maxDocumentUploadSize: CountSchema.positive(),
+    maxTextUploadSize: CountSchema.positive(),
+    isAttachmentAvailable: z.literal(true),
+});
+export type TextChatConfig = z.infer<typeof TextChatConfigSchema>;
+
+export const TextChatSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    // Independent Page.categoryId; immutable after creation.
+    categoryId: z.string().uuid().nullable(),
+    // Optional for legacy servers; only successful assistant messages determine this value.
+    lastUsedAiModelId: z.string().uuid().nullable().optional(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+export type TextChat = z.infer<typeof TextChatSchema>;
+
+export const TextChatMessageSchema = z.object({
+    uuid: z.string().uuid(),
+    chatId: z.string().uuid(),
+    role: z.nativeEnum(TEXT_CHAT_MESSAGE_ROLE),
+    status: z.nativeEnum(TEXT_CHAT_MESSAGE_STATUS),
+    text: z.string(),
+    modelId: z.string().uuid().nullable(),
+    files: z.array(TextChatFileSchema),
+    errorCode: z.nativeEnum(TEXT_CHAT_ERROR_CODE).nullable(),
+    price: CountSchema.nullable(),
+    createdAt: TimestampSchema,
+});
+export type TextChatMessage = z.infer<typeof TextChatMessageSchema>;
+
+export const TextChatPriceSchema = z.object({
+    price: CountSchema.positive(),
+    // Distances from the requested draft inputLength; null means no boundary in that direction.
+    charsUntilNextPriceIncrease: CountSchema.positive().nullable(),
+    charsUntilNextPriceDecrease: CountSchema.positive().nullable(),
+});
+export type TextChatPrice = z.infer<typeof TextChatPriceSchema>;

package/models/text-chat/provider-config.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { TEXT_PROVIDER_CODE } from '../../constants/text-provider';
+import { TOOL_MODEL_STATUS } from '../../constants/tools';
+
+/** Deployment configuration only. Never accepted as a chat request or exposed by public config. */
+export const TextProviderSeedSchema = z
+    .object({
+        providers: z
+            .array(
+                z
+                    .object({
+                        code: z.nativeEnum(TEXT_PROVIDER_CODE),
+                        title: z.string().trim().min(1),
+                        status: z.nativeEnum(TOOL_MODEL_STATUS),
+                    })
+                    .strict(),
+            )
+            .max(3),
+        links: z.array(
+            z
+                .object({
+                    modelId: z.string().uuid(),
+                    providerCode: z.nativeEnum(TEXT_PROVIDER_CODE),
+                    providerModel: z.string().trim().min(1),
+                    priority: z.number().int().safe(),
+                    trafficPercent: z.number().int().min(0).max(100),
+                })
+                .strict(),
+        ),
+    })
+    .strict()
+    .superRefine((config, context) => {
+        if (
+            new Set(config.providers.map((provider) => provider.code)).size !==
+            config.providers.length
+        ) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: 'Duplicate provider' });
+        }
+        const pairs = config.links.map((link) => `${link.modelId}:${link.providerCode}`);
+        if (new Set(pairs).size !== pairs.length) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Duplicate model/provider link',
+            });
+        }
+    });
+export type TextProviderSeed = z.infer<typeof TextProviderSeedSchema>;

package/models/text-chat/stream.schema.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { TEXT_CHAT_ERROR_CODE, TEXT_CHAT_STREAM_EVENT } from '../../constants/text-chat';
+
+const correlation = {
+    chatId: z.string().uuid(),
+    messageId: z.string().uuid(),
+    sequence: z.number().int().safe().nonnegative(),
+};
+
+export const TextChatStreamFrameSchema = z.discriminatedUnion('type', [
+    z
+        .object({
+            ...correlation,
+            type: z.literal(TEXT_CHAT_STREAM_EVENT.START),
+            userMessageId: z.string().uuid(),
+            modelId: z.string().uuid(),
+        })
+        .strict(),
+    z
+        .object({
+            ...correlation,
+            type: z.literal(TEXT_CHAT_STREAM_EVENT.DELTA),
+            delta: z.string().min(1),
+        })
+        .strict(),
+    z
+        .object({
+            ...correlation,
+            type: z.literal(TEXT_CHAT_STREAM_EVENT.FINISH),
+            price: z.number().int().safe().positive(),
+        })
+        .strict(),
+    z
+        .object({
+            ...correlation,
+            type: z.literal(TEXT_CHAT_STREAM_EVENT.ERROR),
+            code: z.nativeEnum(TEXT_CHAT_ERROR_CODE),
+            message: z.string().min(1).optional(),
+        })
+        .strict(),
+]);
+
+export type TextChatStreamFrame = z.infer<typeof TextChatStreamFrameSchema>;

package/models/user.schema.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { USER_ROLE, USER_STATUS } from '../constants';
 
+export const EmailInputSchema = z.string().trim().toLowerCase().email();
+
 export const UserSchema = z.object({
     uuid: z.string().uuid().optional(),
     siteId: z.string().uuid().optional(),
-    email: z.string().email(),
+    email: EmailInputSchema,
     password: z.string().min(6).max(128),
     role: z.nativeEnum(USER_ROLE).optional(),
     status: z.nativeEnum(USER_STATUS).optional(),

package/package.json

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

package/queries/catalog/index.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { CatalogGroupAdminSchema, PublicCatalogGroupSchema } from '../../models/catalog';
+
+export namespace GetCatalogCommand {
+    export const ResponseSchema = z.object({ data: z.array(PublicCatalogGroupSchema) });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+export namespace GetCatalogGroupCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() }).strict();
+    export const ResponseSchema = z.object({ data: CatalogGroupAdminSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+export namespace FindCatalogGroupsCommand {
+    export const RequestQuerySchema = z
+        .object({
+            limit: z.coerce.number().int().min(1).max(100).default(20),
+            offset: z.coerce.number().int().min(0).default(0),
+        })
+        .strict();
+    export const ResponseSchema = z.object({
+        data: z.array(CatalogGroupAdminSchema),
+        meta: z.object({
+            limit: z.number().int().positive(),
+            offset: z.number().int().nonnegative(),
+            total: z.number().int().nonnegative(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/index.ts

@@ -10,3 +10,5 @@ export * from './page';
 export * from './marketplace-card';
 export * from './stt';
 export * from './tts';
+export * from './text-chat';
+export * from './catalog';

package/queries/subscription/get-subscriptions-summary.command.ts

@@ -14,6 +14,7 @@ const UserToSubscriptionSummarySchema = z.object({
     carriedOverTokenBalance: z.number().int(),
     status: z.nativeEnum(USER_TO_SUBSCRIPTION_STATUS),
     active: z.boolean(),
+    endDate: z.date().or(z.string().datetime()).nullable(),
     createdAt: z.date().or(z.string().datetime()),
     subscription: SubscriptionSchema,
 });

package/queries/text-chat/category.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { TOOL_TYPE } from '../../constants/tools';
+import { TEXT_CHAT_CATEGORY_SCOPE } from '../../constants/text-chat';
+import {
+    TextChatCategoryAdminSchema,
+    TextChatCategoryPublicSchema,
+} from '../../models/text-chat/category.schema';
+
+const PaginationSchema = z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(20),
+    offset: z.coerce.number().int().min(0).default(0),
+});
+const MetaSchema = z.object({
+    limit: z.number().int().positive(),
+    offset: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+});
+
+export namespace FindTextChatCategoriesCommand {
+    export const RequestQuerySchema = PaginationSchema.strict();
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+    export const ResponseSchema = z.object({
+        data: z.array(TextChatCategoryPublicSchema),
+        meta: MetaSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+export namespace GetTextChatCategoryCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() }).strict();
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const ResponseSchema = z.object({ data: TextChatCategoryPublicSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+export namespace FindAdminTextChatCategoriesCommand {
+    export const RequestQuerySchema = PaginationSchema.extend({
+        toolType: z.nativeEnum(TOOL_TYPE).optional(),
+        scope: z.nativeEnum(TEXT_CHAT_CATEGORY_SCOPE).default(TEXT_CHAT_CATEGORY_SCOPE.ACTIVE),
+    }).strict();
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+    export const ResponseSchema = z.object({
+        data: z.array(TextChatCategoryAdminSchema),
+        meta: MetaSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+export namespace GetAdminTextChatCategoryCommand {
+    export const RequestParamsSchema = GetTextChatCategoryCommand.RequestParamsSchema;
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const ResponseSchema = z.object({ data: TextChatCategoryAdminSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/text-chat/index.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export * from './category';
+import {
+    TextChatConfigSchema,
+    TextChatMessageSchema,
+    TextChatSchema,
+} from '../../models/text-chat';
+
+export namespace GetTextChatConfigCommand {
+    export const ResponseSchema = z.object({ data: TextChatConfigSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace FindTextChatsCommand {
+    export const RequestQuerySchema = z.object({
+        limit: z.coerce.number().int().min(1).max(100).default(20),
+        offset: z.coerce.number().int().min(0).default(0),
+        search: z.string().trim().max(200).optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+    export const ResponseSchema = z.object({
+        data: z.array(TextChatSchema),
+        meta: z.object({
+            limit: z.number().int().positive(),
+            offset: z.number().int().nonnegative(),
+            total: z.number().int().nonnegative(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace GetTextChatCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const ResponseSchema = z.object({ data: TextChatSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace FindTextChatMessagesCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const RequestQuerySchema = z.object({
+        limit: z.coerce.number().int().min(1).max(100).default(50),
+        offset: z.coerce.number().int().min(0).default(0),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+    export const ResponseSchema = z.object({
+        data: z.array(TextChatMessageSchema),
+        meta: z.object({
+            limit: z.number().int().positive(),
+            offset: z.number().int().nonnegative(),
+            total: z.number().int().nonnegative(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}