@purpleschool/multisite 0.0.35 → 0.0.41

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.35",
+  "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/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>;
+}