@gigapay-dev/contracts 1.8.6 → 3.0.0

package/commands/products/create.ts

@@ -1,134 +0,0 @@
-import z from "zod";
-import { ProductType, DeliveryType, MediaType, SystemRequirementType } from "./enums";
-
-/** Запрос на создание продукта */
-export const ProductCreateRequestSchema = z.object({
-	/** URL-friendly идентификатор */
-	slug: z.string().min(1),
-	/** Название продукта */
-	title: z.string().min(1),
-	/** Оригинальное название (на языке оригинала) */
-	originalTitle: z.string().optional(),
-	/** Тип продукта */
-	type: ProductType,
-	/** ID категории */
-	categoryId: z.number().int().positive(),
-	/** ID родительского продукта (для DLC) */
-	parentProductId: z.number().int().positive().optional(),
-	/** Полное описание */
-	description: z.string().optional(),
-	/** Кастомное описание */
-	customDescription: z.string().optional(),
-	/** Краткое описание */
-	shortDescription: z.string().optional(),
-	/** URL обложки */
-	coverImageUrl: z.string().url().optional(),
-	/** Разработчик */
-	developer: z.string().optional(),
-	/** Издатель */
-	publisher: z.string().optional(),
-	/** Дата выхода (ISO datetime) */
-	releaseDate: z.string().datetime().optional(),
-	/** Steam App ID */
-	steamAppId: z.number().int().optional(),
-	/** Мультиплеер */
-	hasMultiplayer: z.boolean().default(false),
-	/** Кооператив */
-	hasCoop: z.boolean().default(false),
-	/** Одиночная игра */
-	hasSinglePlayer: z.boolean().default(true),
-	/** SEO: заголовок */
-	metaTitle: z.string().optional(),
-	/** SEO: описание */
-	metaDescription: z.string().optional(),
-	/** ID жанров для привязки */
-	genreIds: z.array(z.number().int().positive()).optional(),
-	/** ID тегов для привязки */
-	tagIds: z.array(z.number().int().positive()).optional(),
-	/** ID регионов для привязки */
-	regionIds: z.array(z.number().int().positive()).optional(),
-});
-
-export type ProductCreateRequest = z.infer<typeof ProductCreateRequestSchema>;
-
-/** Запрос на создание варианта продукта */
-export const VariantCreateRequestSchema = z.object({
-	/** Название варианта */
-	name: z.string().min(1),
-	/** Артикул */
-	sku: z.string().min(1),
-	/** Цена */
-	price: z.number().positive(),
-	/** Цена до скидки */
-	originalPrice: z.number().positive().optional(),
-	/** Себестоимость */
-	costPrice: z.number().positive().optional(),
-	/** Сумма пополнения (для TOPUP) */
-	topupAmount: z.number().positive().optional(),
-	/** Валюта */
-	currency: z.string().optional(),
-	/** Длительность подписки (дни) */
-	durationDays: z.number().int().positive().optional(),
-	/** Платформа (Steam, Epic Games, ...) */
-	platform: z.string().optional(),
-	/** Код региона */
-	regionCode: z.string().optional(),
-	/** Тип доставки */
-	deliveryType: DeliveryType.default("AUTOMATIC"),
-});
-
-export type VariantCreateRequest = z.infer<typeof VariantCreateRequestSchema>;
-
-/** Запрос на импорт ключей */
-export const KeysImportRequestSchema = z.object({
-	/** Массив ключей для импорта */
-	keys: z.array(z.string().min(1)).min(1),
-});
-
-export type KeysImportRequest = z.infer<typeof KeysImportRequestSchema>;
-
-/** Ответ на импорт ключей */
-export const KeysImportResponseSchema = z.object({
-	/** Количество импортированных ключей */
-	imported: z.number(),
-});
-
-export type KeysImportResponse = z.infer<typeof KeysImportResponseSchema>;
-
-/** Запрос на добавление медиа */
-export const MediaCreateRequestSchema = z.object({
-	/** Тип медиа */
-	type: MediaType,
-	/** URL медиа */
-	url: z.string().url(),
-	/** Alt-текст */
-	alt: z.string().optional(),
-	/** Порядок сортировки */
-	sortOrder: z.number().int().default(0),
-});
-
-export type MediaCreateRequest = z.infer<typeof MediaCreateRequestSchema>;
-
-/** Запрос на upsert системных требований */
-export const SystemRequirementsRequestSchema = z.object({
-	/** Тип: минимальные / рекомендуемые */
-	type: SystemRequirementType,
-	/** Операционная система */
-	os: z.string().optional(),
-	/** Процессор */
-	processor: z.string().optional(),
-	/** Оперативная память */
-	memory: z.string().optional(),
-	/** Видеокарта */
-	graphics: z.string().optional(),
-	/** Место на диске */
-	storage: z.string().optional(),
-	/** DirectX */
-	directx: z.string().optional(),
-	/** Сеть */
-	network: z.string().optional(),
-	/** Дополнительно */
-	additional: z.string().optional(),
-});
-
-export type SystemRequirementsRequest = z.infer<typeof SystemRequirementsRequestSchema>;

package/commands/products/endpoints.ts

@@ -1,108 +0,0 @@
-import z from "zod";
-import { EndpointContract } from "../../types";
-import { ProductFilterSchema } from "./query";
-import { ProductCreateRequestSchema, VariantCreateRequestSchema, KeysImportRequestSchema, KeysImportResponseSchema, MediaCreateRequestSchema, SystemRequirementsRequestSchema } from "./create";
-import { ProductUpdateRequestSchema } from "./update";
-import { ProductCatalogResponseSchema, ProductDetailResponseSchema, CategoryResponseSchema, GenreResponseSchema, RegionResponseSchema, KeysCountResponseSchema } from "./read";
-
-export const ProductEndpoints = {
-	// === Публичные ===
-	catalog: {
-		method: "GET",
-		path: "/products",
-		request: ProductFilterSchema,
-		response: z.object({
-			items: z.array(ProductCatalogResponseSchema),
-			total: z.number(),
-			skip: z.number(),
-			take: z.number(),
-		}),
-	},
-	categories: {
-		method: "GET",
-		path: "/products/categories",
-		response: z.array(CategoryResponseSchema),
-	},
-	genres: {
-		method: "GET",
-		path: "/products/genres",
-		response: z.array(GenreResponseSchema),
-	},
-	regions: {
-		method: "GET",
-		path: "/products/regions",
-		response: z.array(RegionResponseSchema),
-	},
-	getBySlug: {
-		method: "GET",
-		path: "/products/:slug",
-		request: z.object({ slug: z.string() }),
-		response: ProductDetailResponseSchema,
-	},
-
-	// === Администрирование ===
-	create: {
-		method: "POST",
-		path: "/products/admin",
-		request: ProductCreateRequestSchema,
-		response: ProductDetailResponseSchema,
-	},
-	update: {
-		method: "PUT",
-		path: "/products/admin/:id",
-		request: ProductUpdateRequestSchema,
-		response: ProductDetailResponseSchema,
-	},
-	archive: {
-		method: "DELETE",
-		path: "/products/admin/:id",
-		response: z.object({ status: z.string() }),
-	},
-	createVariant: {
-		method: "POST",
-		path: "/products/admin/:productId/variants",
-		request: VariantCreateRequestSchema,
-	},
-	updateVariant: {
-		method: "PUT",
-		path: "/products/admin/variants/:variantId",
-		request: VariantCreateRequestSchema,
-	},
-	importKeys: {
-		method: "POST",
-		path: "/products/admin/variants/:variantId/keys",
-		request: KeysImportRequestSchema,
-		response: KeysImportResponseSchema,
-	},
-	getKeysCount: {
-		method: "GET",
-		path: "/products/admin/variants/:variantId/keys/count",
-		response: KeysCountResponseSchema,
-	},
-	addMedia: {
-		method: "POST",
-		path: "/products/admin/:productId/media",
-		request: MediaCreateRequestSchema,
-	},
-	removeMedia: {
-		method: "DELETE",
-		path: "/products/admin/media/:mediaId",
-	},
-	upsertSystemRequirements: {
-		method: "POST",
-		path: "/products/admin/:productId/system-requirements",
-		request: SystemRequirementsRequestSchema,
-	},
-} satisfies Record<string, EndpointContract>;
-
-export type ProductEndpointKey = keyof typeof ProductEndpoints;
-
-export type GetProductRequest<K extends ProductEndpointKey> =
-	typeof ProductEndpoints[K] extends { request: z.ZodTypeAny }
-		? z.infer<typeof ProductEndpoints[K]["request"]>
-		: never;
-
-export type GetProductResponse<K extends ProductEndpointKey> =
-	typeof ProductEndpoints[K] extends { response: z.ZodTypeAny }
-		? z.infer<typeof ProductEndpoints[K]["response"]>
-		: never;

package/commands/products/enums.ts

@@ -1,33 +0,0 @@
-import z from "zod";
-
-/** Тип продукта */
-export const ProductType = z.enum([
-	"GAME_KEY",
-	"GAME_GIFT",
-	"TOPUP",
-	"SUBSCRIPTION",
-	"IN_GAME_ITEM",
-	"DLC",
-	"CURRENCY",
-]);
-export type ProductType = z.infer<typeof ProductType>;
-
-/** Статус продукта */
-export const ProductStatus = z.enum(["DRAFT", "ACTIVE", "OUT_OF_STOCK", "ARCHIVED"]);
-export type ProductStatus = z.infer<typeof ProductStatus>;
-
-/** Тип доставки варианта */
-export const DeliveryType = z.enum(["AUTOMATIC", "MANUAL", "BOT"]);
-export type DeliveryType = z.infer<typeof DeliveryType>;
-
-/** Тип медиа-контента */
-export const MediaType = z.enum(["SCREENSHOT", "SLIDER", "VIDEO", "TRAILER"]);
-export type MediaType = z.infer<typeof MediaType>;
-
-/** Статус ключа */
-export const KeyStatus = z.enum(["AVAILABLE", "RESERVED", "SOLD"]);
-export type KeyStatus = z.infer<typeof KeyStatus>;
-
-/** Тип системных требований */
-export const SystemRequirementType = z.enum(["minimum", "recommended"]);
-export type SystemRequirementType = z.infer<typeof SystemRequirementType>;

package/commands/products/index.ts

@@ -1,6 +0,0 @@
-export * from "./enums";
-export * from "./create";
-export * from "./update";
-export * from "./read";
-export * from "./query";
-export * from "./endpoints";

package/commands/products/query.ts

@@ -1,52 +0,0 @@
-import z from "zod";
-
-/** Фильтры каталога продуктов */
-export const ProductFilterSchema = z.object({
-	/** Slug категории */
-	category: z.string().optional(),
-	/** Тип продукта (GAME_KEY, TOPUP, ...) */
-	type: z.string().optional(),
-	/** Slugs жанров через запятую */
-	genre: z.string().optional(),
-	/** Slugs тегов через запятую */
-	tag: z.string().optional(),
-	/** Код региона (RU, TR, KZ, GLOBAL) */
-	region: z.string().optional(),
-	/** Платформа (Steam, Epic Games, ...) */
-	platform: z.string().optional(),
-	/** Минимальная цена */
-	minPrice: z.coerce.number().optional(),
-	/** Максимальная цена */
-	maxPrice: z.coerce.number().optional(),
-	/** Фильтр: мультиплеер */
-	hasMultiplayer: z
-		.enum(["true", "false"])
-		.transform(v => v === "true")
-		.optional(),
-	/** Фильтр: кооператив */
-	hasCoop: z
-		.enum(["true", "false"])
-		.transform(v => v === "true")
-		.optional(),
-	/** Фильтр: издатель (частичное совпадение) */
-	publisher: z.string().optional(),
-	/** Минимальный рейтинг */
-	minRating: z.coerce.number().optional(),
-	/** Фильтр: наличие скидки */
-	hasDiscount: z
-		.enum(["true", "false"])
-		.transform(v => v === "true")
-		.optional(),
-	/** Поиск по названию */
-	search: z.string().optional(),
-	/** Поле сортировки */
-	sortBy: z.enum(["price", "popularity", "rating", "releaseDate", "title"]).default("popularity"),
-	/** Направление сортировки */
-	sortDir: z.enum(["asc", "desc"]).default("desc"),
-	/** Смещение для пагинации */
-	skip: z.coerce.number().default(0),
-	/** Количество записей */
-	take: z.coerce.number().default(20),
-});
-
-export type ProductFilter = z.infer<typeof ProductFilterSchema>;

package/commands/products/read.ts

@@ -1,268 +0,0 @@
-import z from "zod";
-import { ProductType, ProductStatus, DeliveryType, MediaType, SystemRequirementType } from "./enums";
-
-// === Вложенные схемы ===
-
-/** Категория (краткая) */
-export const CategoryBriefSchema = z.object({
-	slug: z.string(),
-	name: z.string(),
-});
-
-/** Категория (полная, для списка категорий) */
-export const CategoryResponseSchema = z.object({
-	id: z.number(),
-	slug: z.string(),
-	name: z.string(),
-	description: z.string().nullable(),
-	iconUrl: z.string().nullable(),
-	_count: z.object({
-		products: z.number(),
-	}),
-});
-
-/** Жанр (краткий, без ID) */
-export const GenreBriefSchema = z.object({
-	slug: z.string(),
-	name: z.string(),
-});
-
-/** Жанр (полный, для списка жанров) */
-export const GenreResponseSchema = z.object({
-	id: z.number(),
-	slug: z.string(),
-	name: z.string(),
-	_count: z.object({
-		products: z.number(),
-	}),
-});
-
-/** Тег */
-export const TagBriefSchema = z.object({
-	id: z.number(),
-	slug: z.string(),
-	name: z.string(),
-});
-
-/** Регион (краткий, без ID) */
-export const RegionBriefSchema = z.object({
-	code: z.string(),
-	name: z.string(),
-});
-
-/** Регион (полный, для списка регионов) */
-export const RegionResponseSchema = z.object({
-	id: z.number(),
-	code: z.string(),
-	name: z.string(),
-	_count: z.object({
-		products: z.number(),
-	}),
-});
-
-/** Вариант в каталоге (краткий) */
-export const VariantCatalogSchema = z.object({
-	id: z.number(),
-	name: z.string(),
-	price: z.string(),
-	originalPrice: z.string().nullable(),
-	platform: z.string().nullable(),
-	regionCode: z.string().nullable(),
-});
-
-/** Вариант в детальной карточке */
-export const VariantDetailSchema = z.object({
-	id: z.number(),
-	name: z.string(),
-	sku: z.string(),
-	price: z.string(),
-	originalPrice: z.string().nullable(),
-	topupAmount: z.string().nullable(),
-	currency: z.string().nullable(),
-	durationDays: z.number().nullable(),
-	platform: z.string().nullable(),
-	regionCode: z.string().nullable(),
-	deliveryType: z.string(),
-	inStock: z.boolean(),
-});
-
-/** Медиа */
-export const MediaResponseSchema = z.object({
-	id: z.number(),
-	type: z.string(),
-	url: z.string(),
-	alt: z.string().nullable(),
-});
-
-/** Системные требования */
-export const SystemRequirementsResponseSchema = z.object({
-	type: z.string(),
-	os: z.string().nullable(),
-	processor: z.string().nullable(),
-	memory: z.string().nullable(),
-	graphics: z.string().nullable(),
-	storage: z.string().nullable(),
-	directx: z.string().nullable(),
-	network: z.string().nullable(),
-	additional: z.string().nullable(),
-});
-
-/** DLC в детальной карточке */
-export const DlcBriefSchema = z.object({
-	id: z.number(),
-	slug: z.string(),
-	title: z.string(),
-	coverImageUrl: z.string().nullable(),
-	variants: z.array(z.object({
-		price: z.any(),
-		originalPrice: z.any(),
-	})),
-});
-
-// === Основные схемы ответов ===
-
-/** Продукт в каталоге (карточка) */
-export const ProductCatalogResponseSchema = z.object({
-	id: z.number(),
-	slug: z.string(),
-	title: z.string(),
-	type: z.string(),
-	shortDescription: z.string().nullable(),
-	coverImageUrl: z.string().nullable(),
-	steamRating: z.number().nullable(),
-	hasMultiplayer: z.boolean(),
-	hasCoop: z.boolean(),
-	salesCount: z.number(),
-	publisher: z.string().nullable(),
-	releaseDate: z.coerce.date().nullable(),
-	category: CategoryBriefSchema,
-	genres: z.array(GenreBriefSchema),
-	regions: z.array(RegionBriefSchema),
-	variants: z.array(VariantCatalogSchema),
-	minPrice: z.string().nullable(),
-	hasDiscount: z.boolean(),
-});
-
-/** Продукт (полная детальная карточка) */
-export const ProductDetailResponseSchema = z.object({
-	id: z.number(),
-	slug: z.string(),
-	title: z.string(),
-	originalTitle: z.string().nullable(),
-	type: z.string(),
-	status: z.string(),
-	description: z.string().nullable(),
-	customDescription: z.string().nullable(),
-	shortDescription: z.string().nullable(),
-	coverImageUrl: z.string().nullable(),
-	developer: z.string().nullable(),
-	publisher: z.string().nullable(),
-	releaseDate: z.coerce.date().nullable(),
-	steamAppId: z.number().nullable(),
-	steamRating: z.number().nullable(),
-	hasMultiplayer: z.boolean(),
-	hasCoop: z.boolean(),
-	hasSinglePlayer: z.boolean(),
-	metaTitle: z.string().nullable(),
-	metaDescription: z.string().nullable(),
-	salesCount: z.number(),
-	viewsCount: z.number(),
-	category: CategoryBriefSchema.extend({ id: z.number() }),
-	variants: z.array(VariantDetailSchema),
-	media: z.array(MediaResponseSchema),
-	genres: z.array(TagBriefSchema),
-	tags: z.array(TagBriefSchema),
-	regions: z.array(RegionResponseSchema.omit({ _count: true })),
-	systemRequirements: z.array(SystemRequirementsResponseSchema),
-	dlcs: z.array(DlcBriefSchema),
-	createdAt: z.coerce.date(),
-	updatedAt: z.coerce.date(),
-});
-
-/** Статистика ключей по варианту */
-export const KeysCountResponseSchema = z.object({
-	available: z.number(),
-	sold: z.number(),
-	reserved: z.number(),
-	total: z.number(),
-});
-
-// === Парсинг Steam ===
-
-/** Спарсенные системные требования */
-const ParsedSystemRequirementsSchema = z.object({
-	os: z.string().optional(),
-	processor: z.string().optional(),
-	memory: z.string().optional(),
-	graphics: z.string().optional(),
-	storage: z.string().optional(),
-	directx: z.string().optional(),
-	network: z.string().optional(),
-});
-
-/** Данные игры из Steam Store API */
-const SteamParsedDataSchema = z.object({
-	title: z.string(),
-	originalTitle: z.string().optional(),
-	description: z.string(),
-	shortDescription: z.string(),
-	coverImageUrl: z.string(),
-	developer: z.string().optional(),
-	publisher: z.string().optional(),
-	releaseDate: z.string().optional(),
-	steamAppId: z.number(),
-	steamRating: z.number().optional(),
-	hasMultiplayer: z.boolean(),
-	hasCoop: z.boolean(),
-	hasSinglePlayer: z.boolean(),
-	genres: z.array(z.string()),
-	screenshots: z.array(z.string()),
-	systemRequirements: z.object({
-		minimum: ParsedSystemRequirementsSchema.optional(),
-		recommended: ParsedSystemRequirementsSchema.optional(),
-	}),
-});
-
-/** Региональная цена из Dessly */
-const DesslyRegionPriceSchema = z.object({
-	region: z.string(),
-	price: z.string(),
-	priceOriginal: z.string(),
-	discount: z.string(),
-});
-
-/** Издание игры из Dessly */
-const DesslyEditionSchema = z.object({
-	edition: z.string(),
-	packageId: z.number(),
-	regions: z.array(DesslyRegionPriceSchema),
-});
-
-/** Данные из Dessly API */
-const DesslyParsedDataSchema = z.object({
-	editions: z.array(DesslyEditionSchema),
-});
-
-/** Ответ парсинга игры по Steam App ID */
-export const SteamParseResponseSchema = z.object({
-	steam: SteamParsedDataSchema.nullable(),
-	dessly: DesslyParsedDataSchema.nullable(),
-});
-
-// === Type exports ===
-
-export type CategoryBrief = z.infer<typeof CategoryBriefSchema>;
-export type CategoryResponse = z.infer<typeof CategoryResponseSchema>;
-export type GenreBrief = z.infer<typeof GenreBriefSchema>;
-export type GenreResponse = z.infer<typeof GenreResponseSchema>;
-export type TagBrief = z.infer<typeof TagBriefSchema>;
-export type RegionBrief = z.infer<typeof RegionBriefSchema>;
-export type RegionResponse = z.infer<typeof RegionResponseSchema>;
-export type VariantCatalog = z.infer<typeof VariantCatalogSchema>;
-export type VariantDetail = z.infer<typeof VariantDetailSchema>;
-export type MediaResponse = z.infer<typeof MediaResponseSchema>;
-export type SystemRequirementsResponse = z.infer<typeof SystemRequirementsResponseSchema>;
-export type ProductCatalogResponse = z.infer<typeof ProductCatalogResponseSchema>;
-export type ProductDetailResponse = z.infer<typeof ProductDetailResponseSchema>;
-export type KeysCountResponse = z.infer<typeof KeysCountResponseSchema>;
-export type SteamParseResponse = z.infer<typeof SteamParseResponseSchema>;

package/commands/products/update.ts

@@ -1,11 +0,0 @@
-import { z } from "zod";
-import { ProductCreateRequestSchema } from "./create";
-import { ProductStatus } from "./enums";
-
-/** Запрос на обновление продукта (частичное) */
-export const ProductUpdateRequestSchema = ProductCreateRequestSchema.partial().extend({
-	/** Статус продукта */
-	status: ProductStatus.optional(),
-});
-
-export type ProductUpdateRequest = z.infer<typeof ProductUpdateRequestSchema>;

package/commands/promocode-activations/create.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-
-export const PromoCodeActivationCreateSchema = z.object({
-	promocodeId: z.coerce.number(),
-    refferalId: z.coerce.number(),
-    discountValue: z.coerce.number(),
-    activatedAt: z.coerce.date(),
-});
-
-export type PromoCodeActivationCreate = z.infer<typeof PromoCodeActivationCreateSchema>;

package/commands/promocode-activations/index.ts

@@ -1,3 +0,0 @@
-export * from "./create"
-export * from "./read"
-export * from "./update"

package/commands/promocode-activations/read.ts

@@ -1,11 +0,0 @@
-import z from "zod";
-
-export const PromoCodeActivationReadResponseSchema = z.object({
-    id: z.coerce.number().positive(),
-    promocodeId: z.coerce.number().positive(),
-    refferalId: z.coerce.number().positive(),
-    discountValue: z.string(),
-    activatedAt: z.coerce.date(),
-});
-
-export type PromoCodeActivationReadResponse = z.infer<typeof PromoCodeActivationReadResponseSchema>;

package/commands/promocode-activations/update.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-
-export const PromoCodeActivationUpdateSchema = z.object({
-	promocodeId: z.coerce.number().optional(),
-    refferalId: z.coerce.number().optional(),
-    discountValue: z.coerce.number().optional(),
-    activatedAt: z.coerce.date().nullable().optional(),
-});
-
-export type PromoCodeActivationUpdate = z.infer<typeof PromoCodeActivationUpdateSchema>;

package/commands/promocodes/create.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import { PromoCodeStatus, PromoCodeType } from "./enums";
-
-export const PromoCodeCreateSchema = z.object({
-	value: z.string(),
-	discountValue: z.string(),
-	expiredAt: z.coerce.date().nullable().optional(),
-    startedAt: z.coerce.date().nullable().optional(),
-    createdAt: z.coerce.date().nullable().optional(),
-    deletedAt: z.coerce.date().nullable().optional(),
-    updatedAt: z.coerce.date().nullable().optional(),
-    activationLimit: z.coerce.number().positive().nullable().optional(),
-    activationPerUserLimit: z.coerce.number().positive().nullable().optional(),
-    type: PromoCodeType,
-    status: PromoCodeStatus,
-});
-
-export type PromoCodeCreate = z.infer<typeof PromoCodeCreateSchema>;