@gigapay-dev/contracts 1.8.6 → 2.0.0

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>;

package/commands/promocodes/endpoints.ts

@@ -1,62 +0,0 @@
-import { z } from "zod";
-import { EndpointContract } from "../../types";
-import {
-  PromoCodeCreateSchema,
-} from "./create";
-
-import {
-  PromoCodeReadResponseSchema,
-} from "./read";
-
-import {
-  PromoCodeUpdateSchema,
-} from "./update";
-
-export const PromoCodeEndpoints = {
-    create: {
-        method: "POST",
-        path: "/promo-codes",
-        request: PromoCodeCreateSchema,
-        response: PromoCodeReadResponseSchema,
-    },
-    list: {
-        method: "GET",
-        path: "/promo-codes",
-        request: z.object({}),
-        response: z.array(PromoCodeReadResponseSchema),
-    },
-    getById: {
-        method: "GET",
-        path: "/promo-codes/:id",
-        request: z.object({
-            id: z.coerce.number().positive(),
-        }),
-        response: PromoCodeReadResponseSchema,
-    },
-    getByValue: {
-        method: "GET",
-        path: "/promo-codes/value/:value",
-        request: z.object({
-            value: z.string(),
-        }),
-        response: PromoCodeReadResponseSchema,
-    },
-    update: {
-        method: "PATCH",
-        path: "/promo-codes/:id",
-        request: z.object({
-            id: z.coerce.number().positive(),
-            body: PromoCodeUpdateSchema,
-        }),
-        response: PromoCodeReadResponseSchema,
-  },
-
-} satisfies Record<string, EndpointContract>;
-
-export type PromoCodeEndpointKey = keyof typeof PromoCodeEndpoints;
-
-export type GetPromoCodeRequest<K extends PromoCodeEndpointKey> =
-  z.infer<typeof PromoCodeEndpoints[K]["request"]>;
-
-export type GetPromoCodeResponse<K extends PromoCodeEndpointKey> =
-  z.infer<typeof PromoCodeEndpoints[K]["response"]>;

package/commands/promocodes/enums.ts

@@ -1,9 +0,0 @@
-import z from "zod";
-
-export const PromoCodeType = z.enum(["USER", "AD", "SYSTEM"]);
-export const PromoCodeStatus = z.enum(["ACTIVE", "INACTIVE", "LIMITED", "EXPIRED", "DELETED"]);
-
-export type PromoCodeType = z.infer<typeof PromoCodeType>;
-export type PromoCodeStatus = z.infer<typeof PromoCodeStatus>;
-  
-

package/commands/promocodes/index.ts

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

package/commands/promocodes/read.ts

@@ -1,20 +0,0 @@
-import z from "zod";
-import { PromoCodeStatus, PromoCodeType } from "./enums";
-
-export const PromoCodeReadResponseSchema = z.object({
-    id: z.coerce.number().positive(),
-    value: z.string(),
-    activated: z.coerce.number(),
-    discountValue: z.string(),
-    startedAt: z.coerce.date().nullable().optional(),
-    expiredAt: 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 PromoCodeReadResponse = z.infer<typeof PromoCodeReadResponseSchema>;

package/commands/promocodes/update.ts

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

package/commands/refresh-sessions/create.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-import { RefreshSessionStatus } from "./enums";
-
-export const RefreshSessionCreateSchema = z.object({
-    userId: z.number(),
-    refreshToken: z.string(),
-    expiredAt: z.coerce.date().nullable().optional(),
-    status: RefreshSessionStatus,
-    IP: z.string().nullable().optional(),
-    UA: z.string().nullable().optional(),
-});
-
-export type RefreshSessionCreate = z.infer<typeof RefreshSessionCreateSchema>;

package/commands/refresh-sessions/enums.ts

@@ -1,4 +0,0 @@
-import z from "zod";
-
-export const RefreshSessionStatus = z.enum(['ACTIVE', 'EXPIRED', 'BLOCKED', 'TERMINATED']);
-export type RefreshSessionStatus = z.infer<typeof RefreshSessionStatus>;

package/commands/refresh-sessions/index.ts

@@ -1,4 +0,0 @@
-export * from './create'
-export * from './read'
-export * from './update'
-export * from './enums'

package/commands/refresh-sessions/read.ts

@@ -1,14 +0,0 @@
-import z from "zod";
-import { RefreshSessionStatus } from "./enums";
-
-export const RefreshSessionReadResponseSchema = z.object({
-    id: z.number().positive(),
-    userId: z.number().positive(),
-    refreshToken: z.string(),
-    expiredAt: z.coerce.date().nullable().optional(),
-    status: RefreshSessionStatus,
-    createdAt: z.coerce.date().nullable().optional(),
-    updatedAt: z.coerce.date().nullable().optional(),
-});
-
-export type RefreshSessionReadResponse = z.infer<typeof RefreshSessionReadResponseSchema>;

package/commands/refresh-sessions/update.ts

@@ -1,13 +0,0 @@
-import z from "zod";
-import { RefreshSessionStatus } from "./enums";
-
-export const RefreshSessionUpdateSchema = z.object({
-    userId: z.number().optional(),
-    refreshToken: z.string().optional(),
-    expiredAt: z.coerce.date().nullable().optional(),
-    status: RefreshSessionStatus.optional(),
-    IP: z.string().nullable().optional(),
-    UA: z.string().nullable().optional(),
-});
-
-export type RefreshSessionUpdate = z.infer<typeof RefreshSessionUpdateSchema>;

package/commands/settings/endpoints.ts

@@ -1,52 +0,0 @@
-import { z } from "zod";
-import { EndpointContract } from "../../types";
-import { SettingsReadResponseSchema } from "./read";
-import { SettingsUpdateRequestSchema } from "./update";
-
-export const SettingsEndpoints = {
-    getAll: {
-        method: "GET",
-        path: "/settings",
-        request: z.object({}),
-        response: SettingsReadResponseSchema,
-    },
-    getOne: {
-        method: "GET",
-        path: "/settings/:key",
-        request: z.object({
-            key: z.string(),
-        }),
-        response: z.object({
-            key: z.string(),
-            value: z.union([z.string(), z.boolean()]),
-        }),
-    },
-    updateAll: {
-        method: "PUT",
-        path: "/settings",
-        request: SettingsUpdateRequestSchema,
-        response: SettingsReadResponseSchema,
-    },
-    updateOne: {
-        method: "PUT",
-        path: "/settings/:key",
-        request: z.object({
-            key: z.string(),
-            value: z.union([z.string(), z.boolean()]),
-        }),
-        response: z.object({
-            key: z.string(),
-            value: z.union([z.string(), z.boolean()]),
-        }),
-    },
-} satisfies Record<string, EndpointContract>;
-
-export type SettingsEndpointKey = keyof typeof SettingsEndpoints;
-
-export type GetSettingsRequest<K extends SettingsEndpointKey> = z.infer<
-    typeof SettingsEndpoints[K]["request"]
->;
-
-export type GetSettingsResponse<K extends SettingsEndpointKey> = z.infer<
-    typeof SettingsEndpoints[K]["response"]
->;

package/commands/settings/index.ts

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

package/commands/settings/read.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-
-export const SettingsReadResponseSchema = z.object({
-    desslyDiscount: z.string(),
-    serviceEnabled: z.boolean(),
-    worksEnabled: z.boolean(),
-    paymentsEnabled: z.boolean(),
-});
-
-export type SettingsReadResponse = z.infer<typeof SettingsReadResponseSchema>;

package/commands/settings/update.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-
-export const SettingsUpdateRequestSchema = z.object({
-    desslyDiscount: z.string().optional(),
-    serviceEnabled: z.boolean().optional(),
-    worksEnabled: z.boolean().optional(),
-    paymentsEnabled: z.boolean().optional(),
-});
-
-export type SettingsUpdateRequest = z.infer<typeof SettingsUpdateRequestSchema>;

package/commands/stats/endpoints.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import { EndpointContract } from "../../types";
-import { StatsReadResponseSchema } from "./read";
-import { StatsReadRequestSchema } from "./query";
-
-
-
-export const StatsEndpoints = {
-    list: {
-        method: "GET",
-        path: "/stats",
-        request: StatsReadRequestSchema,
-        response: StatsReadResponseSchema,
-    },
-} satisfies Record<string, EndpointContract>;
-
-export type StatsEndpointKey = keyof typeof StatsEndpoints;
-
-export type GetStatsRequest<K extends StatsEndpointKey> =
-    z.infer<typeof StatsEndpoints[K]["request"]>;
-
-export type GetStatsResponse<K extends StatsEndpointKey> =
-    z.infer<typeof StatsEndpoints[K]["response"]>;

package/commands/stats/index.ts

@@ -1,3 +0,0 @@
-export * from "./read";
-export * from "./query";
-export * from "./endpoints";