@purpleschool/multisite 0.0.35 → 0.0.41

package/build/models/text-chat/provider-config.schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextProviderSeedSchema = void 0;
+const zod_1 = require("zod");
+const text_provider_1 = require("../../constants/text-provider");
+const tools_1 = require("../../constants/tools");
+/** Deployment configuration only. Never accepted as a chat request or exposed by public config. */
+exports.TextProviderSeedSchema = zod_1.z
+    .object({
+    providers: zod_1.z
+        .array(zod_1.z
+        .object({
+        code: zod_1.z.nativeEnum(text_provider_1.TEXT_PROVIDER_CODE),
+        title: zod_1.z.string().trim().min(1),
+        status: zod_1.z.nativeEnum(tools_1.TOOL_MODEL_STATUS),
+    })
+        .strict())
+        .max(3),
+    links: zod_1.z.array(zod_1.z
+        .object({
+        modelId: zod_1.z.string().uuid(),
+        providerCode: zod_1.z.nativeEnum(text_provider_1.TEXT_PROVIDER_CODE),
+        providerModel: zod_1.z.string().trim().min(1),
+        priority: zod_1.z.number().int().safe(),
+        trafficPercent: zod_1.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: zod_1.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: zod_1.z.ZodIssueCode.custom,
+            message: 'Duplicate model/provider link',
+        });
+    }
+});

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

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { TEXT_CHAT_ERROR_CODE, TEXT_CHAT_STREAM_EVENT } from '../../constants/text-chat';
+export declare const TextChatStreamFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.START>;
+    userMessageId: z.ZodString;
+    modelId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.START;
+    userMessageId: string;
+    modelId: string;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.START;
+    userMessageId: string;
+    modelId: string;
+}>, z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.DELTA>;
+    delta: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.DELTA;
+    delta: string;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.DELTA;
+    delta: string;
+}>, z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.FINISH>;
+    price: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.FINISH;
+    price: number;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.FINISH;
+    price: number;
+}>, z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.ERROR>;
+    code: z.ZodNativeEnum<typeof TEXT_CHAT_ERROR_CODE>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.ERROR;
+    code: TEXT_CHAT_ERROR_CODE;
+    message?: string | undefined;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.ERROR;
+    code: TEXT_CHAT_ERROR_CODE;
+    message?: string | undefined;
+}>]>;
+export type TextChatStreamFrame = z.infer<typeof TextChatStreamFrameSchema>;
+//# sourceMappingURL=stream.schema.d.ts.map

package/build/models/text-chat/stream.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.schema.d.ts","sourceRoot":"","sources":["../../../models/text-chat/stream.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAQzF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+BpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/build/models/text-chat/stream.schema.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextChatStreamFrameSchema = void 0;
+const zod_1 = require("zod");
+const text_chat_1 = require("../../constants/text-chat");
+const correlation = {
+    chatId: zod_1.z.string().uuid(),
+    messageId: zod_1.z.string().uuid(),
+    sequence: zod_1.z.number().int().safe().nonnegative(),
+};
+exports.TextChatStreamFrameSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.START), userMessageId: zod_1.z.string().uuid(), modelId: zod_1.z.string().uuid() }))
+        .strict(),
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.DELTA), delta: zod_1.z.string().min(1) }))
+        .strict(),
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.FINISH), price: zod_1.z.number().int().safe().positive() }))
+        .strict(),
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.ERROR), code: zod_1.z.nativeEnum(text_chat_1.TEXT_CHAT_ERROR_CODE), message: zod_1.z.string().min(1).optional() }))
+        .strict(),
+]);

package/build/models/user.schema.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { USER_ROLE, USER_STATUS } from '../constants';
+export declare const EmailInputSchema: z.ZodString;
 export declare const UserSchema: z.ZodObject<{
     uuid: z.ZodOptional<z.ZodString>;
     siteId: z.ZodOptional<z.ZodString>;

package/build/models/user.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.schema.d.ts","sourceRoot":"","sources":["../../models/user.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEtD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAC"}
+{"version":3,"file":"user.schema.d.ts","sourceRoot":"","sources":["../../models/user.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEtD,eAAO,MAAM,gBAAgB,aAA0C,CAAC;AAExE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAC"}

package/build/models/user.schema.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserSchema = void 0;
+exports.UserSchema = exports.EmailInputSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
+exports.EmailInputSchema = zod_1.z.string().trim().toLowerCase().email();
 exports.UserSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid().optional(),
     siteId: zod_1.z.string().uuid().optional(),
-    email: zod_1.z.string().email(),
+    email: exports.EmailInputSchema,
     password: zod_1.z.string().min(6).max(128),
     role: zod_1.z.nativeEnum(constants_1.USER_ROLE).optional(),
     status: zod_1.z.nativeEnum(constants_1.USER_STATUS).optional(),

package/build/queries/catalog/index.d.ts

@@ -0,0 +1,259 @@
+import { z } from 'zod';
+export declare namespace GetCatalogCommand {
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+        } & {
+            items: z.ZodArray<z.ZodObject<{
+                categoryId: z.ZodString;
+                title: z.ZodString;
+                order: z.ZodNumber;
+                page: z.ZodObject<{
+                    uuid: z.ZodString;
+                    alias: z.ZodString;
+                    title: z.ZodString;
+                    toolType: z.ZodNullable<z.ZodNativeEnum<typeof import("../..").TOOL_TYPE>>;
+                    toolOptionId: z.ZodNullable<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                }, {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                categoryId: string;
+                title: string;
+                order: number;
+                page: {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                };
+            }, {
+                categoryId: string;
+                title: string;
+                order: number;
+                page: {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                };
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            title: string;
+            order: number;
+            items: {
+                categoryId: string;
+                title: string;
+                order: number;
+                page: {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                };
+            }[];
+        }, {
+            uuid: string;
+            title: string;
+            order: number;
+            items: {
+                categoryId: string;
+                title: string;
+                order: number;
+                page: {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                };
+            }[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            uuid: string;
+            title: string;
+            order: number;
+            items: {
+                categoryId: string;
+                title: string;
+                order: number;
+                page: {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                };
+            }[];
+        }[];
+    }, {
+        data: {
+            uuid: string;
+            title: string;
+            order: number;
+            items: {
+                categoryId: string;
+                title: string;
+                order: number;
+                page: {
+                    uuid: string;
+                    alias: string;
+                    title: string;
+                    toolType: import("../..").TOOL_TYPE | null;
+                    toolOptionId: string | null;
+                };
+            }[];
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+export declare namespace GetCatalogGroupCommand {
+    const RequestParamsSchema: z.ZodObject<{
+        uuid: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        uuid: string;
+    }, {
+        uuid: string;
+    }>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodObject<{
+            uuid: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+        } & {
+            siteId: z.ZodString;
+            createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+            updatedAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        }, {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        };
+    }, {
+        data: {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+export declare namespace FindCatalogGroupsCommand {
+    const RequestQuerySchema: z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        limit: number;
+        offset: number;
+    }, {
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+        } & {
+            siteId: z.ZodString;
+            createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+            updatedAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        }, {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        }>, "many">;
+        meta: z.ZodObject<{
+            limit: z.ZodNumber;
+            offset: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            limit: number;
+            offset: number;
+            total: number;
+        }, {
+            limit: number;
+            offset: number;
+            total: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        }[];
+        meta: {
+            limit: number;
+            offset: number;
+            total: number;
+        };
+    }, {
+        data: {
+            uuid: string;
+            title: string;
+            order: number;
+            siteId: string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+        }[];
+        meta: {
+            limit: number;
+            offset: number;
+            total: number;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/queries/catalog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../queries/catalog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAwD,CAAC;IACpF,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD;AACD,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,mBAAmB;;;;;;MAAiD,CAAC;IAC3E,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAA8C,CAAC;IAC1E,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD;AACD,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,kBAAkB;;;;;;;;;MAKlB,CAAC;IACP,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/catalog/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindCatalogGroupsCommand = exports.GetCatalogGroupCommand = exports.GetCatalogCommand = void 0;
+const zod_1 = require("zod");
+const catalog_1 = require("../../models/catalog");
+var GetCatalogCommand;
+(function (GetCatalogCommand) {
+    GetCatalogCommand.ResponseSchema = zod_1.z.object({ data: zod_1.z.array(catalog_1.PublicCatalogGroupSchema) });
+})(GetCatalogCommand || (exports.GetCatalogCommand = GetCatalogCommand = {}));
+var GetCatalogGroupCommand;
+(function (GetCatalogGroupCommand) {
+    GetCatalogGroupCommand.RequestParamsSchema = zod_1.z.object({ uuid: zod_1.z.string().uuid() }).strict();
+    GetCatalogGroupCommand.ResponseSchema = zod_1.z.object({ data: catalog_1.CatalogGroupAdminSchema });
+})(GetCatalogGroupCommand || (exports.GetCatalogGroupCommand = GetCatalogGroupCommand = {}));
+var FindCatalogGroupsCommand;
+(function (FindCatalogGroupsCommand) {
+    FindCatalogGroupsCommand.RequestQuerySchema = zod_1.z
+        .object({
+        limit: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+        offset: zod_1.z.coerce.number().int().min(0).default(0),
+    })
+        .strict();
+    FindCatalogGroupsCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.array(catalog_1.CatalogGroupAdminSchema),
+        meta: zod_1.z.object({
+            limit: zod_1.z.number().int().positive(),
+            offset: zod_1.z.number().int().nonnegative(),
+            total: zod_1.z.number().int().nonnegative(),
+        }),
+    });
+})(FindCatalogGroupsCommand || (exports.FindCatalogGroupsCommand = FindCatalogGroupsCommand = {}));

package/build/queries/index.d.ts

@@ -10,4 +10,6 @@ export * from './page';
 export * from './marketplace-card';
 export * from './stt';
 export * from './tts';
+export * from './text-chat';
+export * from './catalog';
 //# sourceMappingURL=index.d.ts.map

package/build/queries/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../queries/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../queries/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/build/queries/index.js

@@ -26,3 +26,5 @@ __exportStar(require("./page"), exports);
 __exportStar(require("./marketplace-card"), exports);
 __exportStar(require("./stt"), exports);
 __exportStar(require("./tts"), exports);
+__exportStar(require("./text-chat"), exports);
+__exportStar(require("./catalog"), exports);