@purpleschool/multisite 0.0.3 → 0.0.5

package/models/image-generation/image-generation-model.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { IMAGE_GENERATION_MODEL_STRATEGY, TOOL_MODEL_STATUS } from '../../constants';
+import { IconVariantsSchema } from '../common';
+import { ImageGenerationModelParamsSchema } from './image-generation-model-params.schema';
+import { ImageGenerationPricingRulesSchema } from './image-generation-pricing-rule.schema';
+
+export const ImageGenerationModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    model: z.string(),
+    description: z.string(),
+    price: z.number().int().nonnegative(),
+    canUse: z.boolean(),
+    pricingRules: ImageGenerationPricingRulesSchema,
+    params: ImageGenerationModelParamsSchema,
+    strategy: z.nativeEnum(IMAGE_GENERATION_MODEL_STRATEGY),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    statusCheckEndpoint: z.string().nullable().optional(),
+    maxPromptLength: z.number().int(),
+    iconVariants: IconVariantsSchema,
+    supportsImageAttachment: z.boolean(),
+    maxAttachedImages: z.number().int(),
+    translatePrompt: z.boolean(),
+    order: z.number().int(),
+    vendorId: z.string().uuid(),
+    createdAt: z.string().datetime().or(z.date()).optional(),
+    updatedAt: z.string().datetime().or(z.date()).optional(),
+});

package/models/image-generation/image-generation-preset.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const ImageGenerationPresetSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    sample: z.string().url(),
+    order: z.number().int(),
+});
+
+export type ImageGenerationPreset = z.infer<typeof ImageGenerationPresetSchema>;

package/models/image-generation/image-generation-pricing-rule.schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { IMAGE_GENERATION_RESOLUTION } from '../../constants';
+
+export const ImageGenerationPricingRuleConditionSchema = z.object({
+    resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
+    withoutSub: z.boolean().optional(),
+});
+export type ImageGenerationPricingRuleCondition = z.infer<
+    typeof ImageGenerationPricingRuleConditionSchema
+>;
+
+export const ImageGenerationPricingRuleSchema = z.object({
+    condition: ImageGenerationPricingRuleConditionSchema,
+    value: z.number().int(),
+});
+export type ImageGenerationPricingRule = z.infer<typeof ImageGenerationPricingRuleSchema>;
+
+export const ImageGenerationPricingRulesSchema = z.array(ImageGenerationPricingRuleSchema);
+export type ImageGenerationPricingRules = z.infer<typeof ImageGenerationPricingRulesSchema>;

package/models/image-generation/image-generation-vendor.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { VendorSchema } from '../tools/vendor.schema';
+import { ImageGenerationModelSchema } from './image-generation-model.schema';
+
+export const ImageGenerationVendorSchema = VendorSchema.extend({
+    models: z.array(ImageGenerationModelSchema),
+});
+
+export type ImageGenerationVendor = z.infer<typeof ImageGenerationVendorSchema>;

package/models/image-generation/index.ts

@@ -0,0 +1,10 @@
+export * from './image-generation-model.schema';
+export * from './image-generation-job.schema';
+export * from './image-generation-job-attempt.schema';
+export * from './image-generation-job-params.schema';
+export * from './image-generation-job-request-params.schema';
+export * from './image-generation-model-params.schema';
+export * from './image-generation-pricing-rule.schema';
+export * from './image-generation-vendor.schema';
+export * from './image-generation-preset.schema';
+export * from './image-generation-config.schema';

package/models/index.ts

@@ -0,0 +1,13 @@
+export * from './user.schema';
+export * from './product.schema';
+export * from './subscription.schema';
+export * from './cloud-payments-widget.schema';
+export * from './cloud-payments-widget-data.schema';
+export * from './image-generation';
+export * from './image-editor';
+export * from './marketplace-card';
+export * from './file.schema';
+export * from './common';
+export * from './tools';
+export * from './page.schema';
+export * from './page-question.schema';

package/models/marketplace-card/index.ts

@@ -0,0 +1,6 @@
+export * from './marketplace-card-model-params.schema';
+export * from './marketplace-card-model.schema';
+export * from './marketplace-card-style-preset.schema';
+export * from './marketplace-card-job-request-params.schema';
+export * from './marketplace-card-job.schema';
+export * from './marketplace-card-config.schema';

package/models/marketplace-card/marketplace-card-config.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { MarketplaceCardModelSchema } from './marketplace-card-model.schema';
+import { MarketplaceCardStylePresetSchema } from './marketplace-card-style-preset.schema';
+
+export const MarketplaceCardConfigSchema = z.object({
+    styles: z.array(MarketplaceCardStylePresetSchema),
+    models: z.array(MarketplaceCardModelSchema),
+});
+
+export type MarketplaceCardConfig = z.infer<typeof MarketplaceCardConfigSchema>;

package/models/marketplace-card/marketplace-card-job-request-params.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const MarketplaceCardJobRequestParamsSchema = z.object({
+    title: z.string().min(1),
+    subtitle: z.string().nullable().optional(),
+    advantages: z.array(z.string()).default([]),
+    tags: z.array(z.string()).default([]),
+    stylePresetId: z.string().uuid().nullable().optional(),
+    isCustom: z.boolean(),
+    customStylePrompt: z.string().nullable().optional(),
+    inputImages: z.array(z.string().uuid()).default([]),
+    backgroundDescription: z.string().nullable().optional(),
+});
+
+export type MarketplaceCardJobRequestParams = z.infer<typeof MarketplaceCardJobRequestParamsSchema>;

package/models/marketplace-card/marketplace-card-job.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { JOB_STATUS, USER_REACTION } from '../../constants';
+const MarketplaceCardInputImageSchema = z.object({
+    uuid: z.string().uuid(),
+    url: z.string().url(),
+});
+
+export const MarketplaceCardJobSchema = z.object({
+    uuid: z.string().uuid(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    title: z.string(),
+    subtitle: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    advantages: z.array(z.string()),
+    tags: z.array(z.string()),
+    stylePresetId: z.string().uuid().nullable(),
+    isCustom: z.boolean(),
+    customStylePrompt: z.string().nullable(),
+    inputImages: z.array(MarketplaceCardInputImageSchema),
+    resultImages: z.array(z.string()).nullable(),
+    backgroundDescription: z.string().nullable(),
+    price: z.number().int().nonnegative(),
+    createdAt: z.string().datetime().or(z.date()).optional(),
+    updatedAt: z.string().datetime().or(z.date()).optional(),
+});
+
+export type MarketplaceCardJob = z.infer<typeof MarketplaceCardJobSchema>;

package/models/marketplace-card/marketplace-card-model-params.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const MarketplaceCardModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number().int().nonnegative(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type MarketplaceCardModelParams = z.infer<typeof MarketplaceCardModelParamsSchema>;

package/models/marketplace-card/marketplace-card-model.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { MARKETPLACE_CARD_STRATEGY, TOOL_MODEL_STATUS } from '../../constants';
+import { IconVariantsSchema } from '../common';
+import { MarketplaceCardModelParamsSchema } from './marketplace-card-model-params.schema';
+
+export const MarketplaceCardModelSchema = z.object({
+    uuid: z.string().uuid(),
+    price: z.number().int().nonnegative(),
+    params: MarketplaceCardModelParamsSchema,
+    iconVariants: IconVariantsSchema,
+    maxPromptLength: z.number().int().positive(),
+    supportsImageAttachment: z.boolean(),
+    maxAttachedImages: z.number().int().nonnegative(),
+});
+
+export type MarketplaceCardModel = z.infer<typeof MarketplaceCardModelSchema>;

package/models/marketplace-card/marketplace-card-style-preset.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const MarketplaceCardStylePresetSchema = z.object({
+    uuid: z.string().uuid(),
+    previewImageUrl: z.string().url(),
+    order: z.number().int().nonnegative(),
+    isActive: z.boolean(),
+});
+
+export type MarketplaceCardStylePreset = z.infer<typeof MarketplaceCardStylePresetSchema>;

package/models/page-question.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const PageQuestionSchema = z.object({
+    uuid: z.string().uuid(),
+    question: z.string().min(3).max(16384),
+    answer: z.string().min(3).max(16384),
+    pageId: z.string().uuid(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/page.schema.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { PageType } from '../constants';
+import { PageQuestionSchema } from './page-question.schema';
+
+export const WriterToolPageMetadataSchema = z.object({
+    type: z.literal(PageType.WRITER_TOOL),
+});
+
+export const EduTaskSolvingToolPageMetadataSchema = z.object({
+    type: z.literal(PageType.EDU_TASK_SOLVING_TOOL),
+});
+
+export const WriterDocumentTypePageMetadataSchema = z.object({
+    type: z.literal(PageType.WRITER_DOCUMENT_TYPE),
+    writerDocumentTypeId: z.string().uuid(),
+});
+
+export const PageMetadataSchema = z.discriminatedUnion('type', [
+    WriterToolPageMetadataSchema,
+    EduTaskSolvingToolPageMetadataSchema,
+    WriterDocumentTypePageMetadataSchema,
+]);
+
+export const PageSchema = z.object({
+    uuid: z.string().uuid(),
+    metaTitle: z.string().min(3).max(16384),
+    metaDescription: z.string().min(3).max(16384),
+    title: z.string().min(3).max(16384),
+    subTitle: z.string().min(3).max(16384),
+    seoTextMd: z.string().min(3).max(16384),
+    alias: z.string().min(3).max(16384),
+    type: z.nativeEnum(PageType),
+    metadata: PageMetadataSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export const PageWithQuestionsSchema = PageSchema.extend({
+    questions: z.array(PageQuestionSchema),
+});

package/models/product.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const ProductSchema = z.object({
+    uuid: z.string().uuid(),
+    siteId: z.string().uuid(),
+    name: z.string().min(1).max(200),
+    description: z.string().min(1).max(2000),
+    tokens: z.number().int().min(0),
+    price: z.number().int().min(0),
+});

package/models/subscription.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const SubscriptionSchema = z.object({
+    uuid: z.string().uuid(),
+    siteId: z.string().uuid(),
+    name: z.string().min(1).max(200),
+    description: z.string().min(1).max(2000),
+    price: z.number().int().min(0),
+    period: z.number().int().min(1).max(36),
+    tokens: z.number().int().min(0),
+    carryoverPercent: z.number().int().min(0).max(100),
+});

package/models/tools/index.ts

@@ -0,0 +1 @@
+export * from './vendor.schema';

package/models/tools/vendor.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../common';
+
+export const VendorSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    order: z.number().int(),
+    iconVariants: IconVariantsSchema,
+});
+
+export type Vendor = z.infer<typeof VendorSchema>;

package/models/user.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { USER_ROLE, USER_STATUS } from '../constants';
+
+export const UserSchema = z.object({
+    uuid: z.string().uuid().optional(),
+    siteId: z.string().uuid().optional(),
+    email: z.string().email(),
+    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.3",
+  "version": "0.0.5",
   "description": "Multisite API contracts (DTO schemas, routes, constants)",
   "type": "commonjs",
   "main": "build/index.js",
@@ -31,12 +31,6 @@
       "default": "./build/api/*/index.js"
     }
   },
-  "files": [
-    "build/**",
-    "package.json",
-    "README.md",
-    "LICENSE"
-  ],
   "scripts": {
     "prepublish": "rm -rf build && tsc",
     "build": "tsc"

package/queries/file/find-files.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { FileSchema } from '../../models';
+
+export namespace FindFilesCommand {
+    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),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(FileSchema),
+        meta: z.object({
+            limit: z.number().int(),
+            offset: z.number().int(),
+            total: z.number().int(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/file/get-file.command.ts

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

package/queries/file/index.ts

@@ -0,0 +1,2 @@
+export * from './get-file.command';
+export * from './find-files.command';

package/queries/image-editor/find-image-editor-jobs.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ImageEditorJobSchema } from '../../models';
+
+export namespace FindImageEditorJobsCommand {
+    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),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(ImageEditorJobSchema),
+        meta: z.object({
+            limit: z.number().int(),
+            offset: z.number().int(),
+            total: z.number().int(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/image-editor/get-image-editor-config.command.ts

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

package/queries/image-editor/get-image-editor-job.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ImageEditorJobSchema } from '../../models';
+
+export namespace GetImageEditorJobCommand {
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageEditorJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/image-editor/get-image-editor-price.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ImageEditorJobRequestParamsSchema } from '../../models';
+
+export namespace GetImageEditorPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        params: ImageEditorJobRequestParamsSchema.optional().default({ imageUrls: [] }),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            price: z.number().int().nonnegative(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/image-editor/index.ts

@@ -0,0 +1,4 @@
+export * from './get-image-editor-config.command';
+export * from './get-image-editor-job.command';
+export * from './find-image-editor-jobs.command';
+export * from './get-image-editor-price.command';

package/queries/image-generation/find-image-generation-jobs.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ImageGenerationJobSchema } from '../../models';
+
+export namespace FindImageGenerationJobsCommand {
+    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),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(ImageGenerationJobSchema),
+        meta: z.object({
+            limit: z.number().int(),
+            offset: z.number().int(),
+            total: z.number().int(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/image-generation/get-image-generation-config.command.ts

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

package/queries/image-generation/get-image-generation-job.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ImageGenerationJobSchema } from '../../models';
+
+export namespace GetImageGenerationJobCommand {
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ImageGenerationJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/image-generation/get-image-generation-price.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { IMAGE_GENERATION_RESOLUTION } from '../../constants';
+
+export namespace GetImageGenerationPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        params: z.object({
+            resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
+        }),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            price: z.number().int().nonnegative(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/image-generation/index.ts

@@ -0,0 +1,4 @@
+export * from './get-image-generation-config.command';
+export * from './get-image-generation-job.command';
+export * from './find-image-generation-jobs.command';
+export * from './get-image-generation-price.command';

package/queries/index.ts

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

package/queries/marketplace-card/find-marketplace-card-jobs.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { MarketplaceCardJobSchema } from '../../models';
+
+export namespace FindMarketplaceCardJobsCommand {
+    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),
+        title: z.string().min(1).optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(MarketplaceCardJobSchema),
+        meta: z.object({
+            limit: z.number().int(),
+            offset: z.number().int(),
+            total: z.number().int(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/marketplace-card/get-marketplace-card-config.command.ts

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

package/queries/marketplace-card/get-marketplace-card-job.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { MarketplaceCardJobSchema } from '../../models';
+
+export namespace GetMarketplaceCardJobCommand {
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: MarketplaceCardJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/marketplace-card/get-marketplace-card-price.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export namespace GetMarketplaceCardPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            price: z.number().int().nonnegative(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/marketplace-card/index.ts

@@ -0,0 +1,4 @@
+export * from './get-marketplace-card-config.command';
+export * from './get-marketplace-card-price.command';
+export * from './get-marketplace-card-job.command';
+export * from './find-marketplace-card-jobs.command';

package/queries/page/find-all-page-questions.query.ts

@@ -0,0 +1,14 @@
+import { PageQuestionSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace FindAllPageQuestionsQuery {
+    export const RequestQuerySchema = z.object({});
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PageQuestionSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/queries/page/find-page-question-by-uuid.query.ts

@@ -0,0 +1,16 @@
+import { PageQuestionSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace FindPageQuestionByUUIDQuery {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageQuestionSchema.nullable(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}