@purpleschool/multisite 0.0.2 → 0.0.4

package/commands/auth/vk-login.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export namespace VKLoginCommand {
+    export const RequestSchema = z.object({
+        code: z.string(),
+        code_verifier: z.string(),
+        device_id: z.string(),
+        state: z.string(),
+        marketingConsent: z.boolean().default(false),
+        partnerId: z.string().uuid().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            accessToken: z.string(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/auth/yandex-login.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+export namespace YandexLoginCommand {
+    export const RequestSchema = z.object({
+        code: z.string(),
+        code_verifier: z.string(),
+        marketingConsent: z.boolean().default(false),
+        partnerId: z.string().uuid().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            accessToken: z.string(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/file/index.ts

@@ -0,0 +1 @@
+export * from './upload-file.command';

package/commands/file/upload-file.command.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { FileSchema } from '../../models';
+
+export namespace UploadFileCommand {
+    export const ResponseSchema = z.object({
+        data: FileSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/execute-image-editor.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ImageEditorJobRequestParamsSchema, ImageEditorJobSchema } from '../../models';
+
+export namespace ExecuteImageEditorCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        prompt: z.string().min(1).max(5000),
+        params: ImageEditorJobRequestParamsSchema,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageEditorJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/index.ts

@@ -0,0 +1,7 @@
+export * from './proxy-image-editor-callback.command';
+export * from './execute-image-editor.command';
+export * from './retry-image-editor-job.command';
+export * from './set-reaction-to-image-editor-job.command';
+export * from './update-image-editor-job-title.command';
+export * from './soft-delete-image-editor-job-by-uuid.command';
+export * from './soft-delete-image-editor-jobs-by-criteria.command';

package/commands/image-editor/proxy-image-editor-callback.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export namespace ProxyImageEditorCallbackCommand {
+    export const RequestSchema = z.object({
+        jobId: z.string().min(1),
+        imageUrl: z.string().url().optional(),
+        error: z.string().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        ok: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/retry-image-editor-job.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ImageEditorJobRequestParamsSchema, ImageEditorJobSchema } from '../../models';
+
+export namespace RetryImageEditorJobCommand {
+    export const RequestSchema = z.object({
+        prompt: z.string().min(1).max(5000).optional(),
+        modelId: z.string().uuid().optional(),
+        params: ImageEditorJobRequestParamsSchema.optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageEditorJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/set-reaction-to-image-editor-job.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ImageEditorJobSchema } from '../../models';
+import { USER_REACTION } from '../../constants';
+
+export namespace SetReactionToImageEditorJobCommand {
+    export const RequestSchema = z.object({
+        reaction: z.nativeEnum(USER_REACTION).nullable(),
+        dislikeReason: z.string().nullable().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageEditorJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/soft-delete-image-editor-job-by-uuid.command.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export namespace SoftDeleteImageEditorJobByUuidCommand {
+    export const ResponseSchema = z.object({
+        data: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/soft-delete-image-editor-jobs-by-criteria.command.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export namespace SoftDeleteImageEditorJobsByCriteriaCommand {
+    export const ResponseSchema = z.object({
+        data: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-editor/update-image-editor-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ImageEditorJobSchema } from '../../models';
+
+export namespace UpdateImageEditorJobTitleCommand {
+    export const RequestSchema = z.object({
+        title: z.string().min(1).max(200),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageEditorJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/execute-image-generation.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ImageGenerationJobRequestParamsSchema, ImageGenerationJobSchema } from '../../models';
+
+export namespace ExecuteImageGenerationCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        prompt: z.string().min(1).max(4000),
+        presetId: z.string().uuid().nullable().optional(),
+        params: ImageGenerationJobRequestParamsSchema,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageGenerationJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/index.ts

@@ -0,0 +1,7 @@
+export * from './execute-image-generation.command';
+export * from './retry-image-generation-job.command';
+export * from './set-reaction-to-image-generation-job.command';
+export * from './update-image-generation-job-title.command';
+export * from './soft-delete-image-generation-job-by-uuid.command';
+export * from './soft-delete-image-generation-jobs-by-criteria.command';
+export * from './proxy-image-generation-callback.command';

package/commands/image-generation/proxy-image-generation-callback.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export namespace ProxyImageGenerationCallbackCommand {
+    export const RequestSchema = z.object({
+        model: z.string(),
+        response: z
+            .object({
+                data: z.array(z.string()),
+                externalId: z.string(),
+                type: z.string(),
+                errorMsg: z.string().optional(),
+            })
+            .optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        ok: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/retry-image-generation-job.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ImageGenerationJobRequestParamsSchema, ImageGenerationJobSchema } from '../../models';
+
+export namespace RetryImageGenerationJobCommand {
+    export const RequestSchema = z.object({
+        prompt: z.string().min(1).max(4000).optional(),
+        modelId: z.string().uuid().optional(),
+        presetId: z.string().uuid().nullable().optional(),
+        params: ImageGenerationJobRequestParamsSchema.optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageGenerationJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/set-reaction-to-image-generation-job.command.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../constants';
+import { ImageGenerationJobSchema } from '../../models';
+
+export namespace SetReactionToImageGenerationJobCommand {
+    export const RequestSchema = z
+        .object({
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .superRefine((data, ctx) => {
+            if (data.reaction !== USER_REACTION.DISLIKE && data.dislikeReason) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: 'Dislike reason is not allowed when reaction is not dislike',
+                    path: ['dislikeReason'],
+                });
+            }
+        });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageGenerationJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/soft-delete-image-generation-job-by-uuid.command.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export namespace SoftDeleteImageGenerationJobByUuidCommand {
+    export const ResponseSchema = z.object({
+        data: z.boolean(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/soft-delete-image-generation-jobs-by-criteria.command.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export namespace SoftDeleteImageGenerationJobsByCriteriaCommand {
+    export const ResponseSchema = z.object({
+        data: z.boolean(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/image-generation/update-image-generation-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ImageGenerationJobSchema } from '../../models';
+
+export namespace UpdateImageGenerationJobTitleCommand {
+    export const RequestSchema = z.object({
+        title: z.string().min(1).max(200),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageGenerationJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/index.ts

@@ -0,0 +1,11 @@
+export * from './auth';
+export * from './product';
+export * from './subscription';
+export * from './payment';
+export * from './transaction';
+export * from './image-generation';
+export * from './image-editor';
+export * from './marketplace-card';
+export * from './file';
+export * from './unregistered-user';
+export * from './page';

package/commands/marketplace-card/execute-marketplace-card.command.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { MarketplaceCardJobRequestParamsSchema, MarketplaceCardJobSchema } from '../../models';
+
+export namespace ExecuteMarketplaceCardCommand {
+    export const RequestSchema = MarketplaceCardJobRequestParamsSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: MarketplaceCardJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/marketplace-card/index.ts

@@ -0,0 +1,6 @@
+export * from './execute-marketplace-card.command';
+export * from './retry-marketplace-card-job.command';
+export * from './set-reaction-to-marketplace-card-job.command';
+export * from './update-marketplace-card-job-title.command';
+export * from './soft-delete-marketplace-card-job-by-uuid.command';
+export * from './soft-delete-marketplace-card-jobs-by-criteria.command';

package/commands/marketplace-card/retry-marketplace-card-job.command.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { MarketplaceCardJobSchema } from '../../models';
+
+export namespace RetryMarketplaceCardJobCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        title: z.string().min(1).optional(),
+        subtitle: z.string().nullable().optional(),
+        advantages: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional(),
+        stylePresetId: z.string().uuid().nullable().optional(),
+        isCustom: z.boolean().optional(),
+        customStylePrompt: z.string().nullable().optional(),
+        inputImages: z.array(z.string().uuid()).optional(),
+        backgroundDescription: z.string().nullable().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: MarketplaceCardJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/marketplace-card/set-reaction-to-marketplace-card-job.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../constants';
+import { MarketplaceCardJobSchema } from '../../models';
+
+export namespace SetReactionToMarketplaceCardJobCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestSchema = z.object({
+        reaction: z.nativeEnum(USER_REACTION).nullable(),
+        dislikeReason: z.string().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: MarketplaceCardJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/marketplace-card/soft-delete-marketplace-card-job-by-uuid.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace SoftDeleteMarketplaceCardJobByUuidCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.literal(true),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/marketplace-card/soft-delete-marketplace-card-jobs-by-criteria.command.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export namespace SoftDeleteMarketplaceCardJobsByCriteriaCommand {
+    export const ResponseSchema = z.object({
+        data: z.literal(true),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/marketplace-card/update-marketplace-card-job-title.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { MarketplaceCardJobSchema } from '../../models';
+
+export namespace UpdateMarketplaceCardJobTitleCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestSchema = z.object({
+        title: z.string().min(1).max(200),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: MarketplaceCardJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/create-page-question.command.ts

@@ -0,0 +1,18 @@
+import { PageQuestionSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace CreatePageQuestionCommand {
+    export const RequestSchema = PageQuestionSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageQuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/create-page.command.ts

@@ -0,0 +1,18 @@
+import { PageSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace CreatePageCommand {
+    export const RequestSchema = PageSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/delete-page-question.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DeletePageQuestionCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/delete-page.command.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export namespace DeletePageCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.void();
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/find-page-by-alias.command.ts

@@ -0,0 +1,28 @@
+import { PageSchema, PageWithQuestionsSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace FindPageByAliasCommand {
+    export const RequestSchema = PageSchema.pick({
+        alias: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PageWithQuestionsSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export const ResponseByAliasSchema = z.object({
+        data: PageWithQuestionsSchema,
+    });
+
+    export const ResponseByAllSchema = z.object({
+        data: z.array(PageWithQuestionsSchema),
+    });
+
+    export type ResponseByAll = z.infer<typeof ResponseByAllSchema>;
+
+    export type ResponseByUUID = z.infer<typeof ResponseByAliasSchema>;
+}

package/commands/page/find-page-by-criteria.command.ts

@@ -0,0 +1,24 @@
+import { PageWithQuestionsSchema } from '../../models';
+import { z } from 'zod';
+import { PageType } from '../../constants/page';
+
+export namespace FindPageByCriteriaCommand {
+    export const RequestQuerySchema = z.object({
+        title: z.string().optional(),
+        alias: z.string().optional(),
+        type: z.nativeEnum(PageType).optional(),
+        uuid: z.string().uuid().optional(),
+        limit: z.coerce.number().min(1).optional(),
+        offset: z.coerce.number().min(0).default(0).optional(),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PageWithQuestionsSchema),
+        totalPages: z.number(),
+        page: z.number(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/find-page.command.ts

@@ -0,0 +1,22 @@
+import { PageSchema, PageWithQuestionsSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace FindPageCommand {
+    export const RequestSchema = PageSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PageWithQuestionsSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export const ResponseByUUIDSchema = z.object({
+        data: PageWithQuestionsSchema,
+    });
+
+    export type ResponseByUUID = z.infer<typeof ResponseByUUIDSchema>;
+}

package/commands/page/index.ts

@@ -0,0 +1,9 @@
+export * from './create-page.command';
+export * from './update-page.command';
+export * from './delete-page.command';
+export * from './find-page.command';
+export * from './find-page-by-alias.command';
+export * from './find-page-by-criteria.command';
+export * from './create-page-question.command';
+export * from './update-page-question.command';
+export * from './delete-page-question.command';

package/commands/page/update-page-question.command.ts

@@ -0,0 +1,24 @@
+import { PageQuestionSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace UpdatePageQuestionCommand {
+    export const RequestSchema = PageQuestionSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageQuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/update-page.command.ts

@@ -0,0 +1,24 @@
+import { PageSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace UpdatePageCommand {
+    export const RequestSchema = PageSchema.omit({
+        createdAt: true,
+        updatedAt: true,
+        uuid: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}