@lyxa.ai/marketing 1.0.47 → 1.0.49

package/dist/lib/modules/tournament/tournament.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.router.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa3B,CAAC"}

package/dist/lib/modules/tournament/tournament.router.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tournamentRouter = void 0;
+const trpc_1 = require("@lyxa.ai/core/dist/libraries/trpc");
+const error_handler_1 = require("@lyxa.ai/core/dist/utilities/error-handler");
+const response_1 = require("@lyxa.ai/core/dist/utilities/response");
+const config_router_1 = require("./config/config.router");
+const team_router_1 = require("./team/team.router");
+const match_router_1 = require("./match/match.router");
+const participant_router_1 = require("./participant/participant.router");
+const prediction_router_1 = require("./prediction/prediction.router");
+const tournament_validation_1 = require("./tournament.validation");
+const tournament_service_1 = require("./tournament.service");
+exports.tournamentRouter = (0, trpc_1.createTRPCRouter)({
+    config: config_router_1.configRouter,
+    team: team_router_1.teamRouter,
+    match: match_router_1.matchRouter,
+    participant: participant_router_1.participantRouter,
+    prediction: prediction_router_1.predictionRouter,
+    getActive: trpc_1.publicProcedure.output(tournament_validation_1.ActiveTournamentResponseSchema).query(() => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await tournament_service_1.tournamentService.getActive();
+        return (0, response_1.response)('Active tournament fetched successfully', result);
+    })),
+});
+//# sourceMappingURL=tournament.router.js.map

package/dist/lib/modules/tournament/tournament.router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.router.js","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":";;;AAAA,4DAAoF;AACpF,8EAAwE;AACxE,oEAA+D;AAC/D,0DAAoD;AACpD,oDAA8C;AAC9C,uDAAiD;AACjD,yEAAmE;AACnE,sEAAgE;AAChE,mEAAuE;AACvE,6DAAkE;AAErD,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,MAAM,EAAE,4BAAY;IACpB,IAAI,EAAE,wBAAU;IAChB,KAAK,EAAE,0BAAW;IAClB,WAAW,EAAE,sCAAiB;IAC9B,UAAU,EAAE,oCAAgB;IAE5B,SAAS,EAAE,sBAAe,CAAC,MAAM,CAAC,sDAA8B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAC5E,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,SAAS,EAAE,CAAC;QACzC,OAAO,IAAA,mBAAQ,EAAC,wCAAwC,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC,CAAC,CACF;CACD,CAAC,CAAC","sourcesContent":["import {createTRPCRouter, publicProcedure} from '@lyxa.ai/core/dist/libraries/trpc';\nimport {ErrorHandler} from '@lyxa.ai/core/dist/utilities/error-handler';\nimport {response} from '@lyxa.ai/core/dist/utilities/response';\nimport {configRouter} from './config/config.router';\nimport {teamRouter} from './team/team.router';\nimport {matchRouter} from './match/match.router';\nimport {participantRouter} from './participant/participant.router';\nimport {predictionRouter} from './prediction/prediction.router';\nimport {ActiveTournamentResponseSchema} from './tournament.validation';\nimport {tournamentService as service} from './tournament.service';\n\nexport const tournamentRouter = createTRPCRouter({\n\tconfig: configRouter,\n\tteam: teamRouter,\n\tmatch: matchRouter,\n\tparticipant: participantRouter,\n\tprediction: predictionRouter,\n\n\tgetActive: publicProcedure.output(ActiveTournamentResponseSchema).query(() =>\n\t\tErrorHandler.wrapAsync(async () => {\n\t\t\tconst result = await service.getActive();\n\t\t\treturn response('Active tournament fetched successfully', result);\n\t\t})\n\t),\n});\n"]}

package/dist/lib/modules/tournament/tournament.service.d.ts

@@ -0,0 +1,8 @@
+import { ActiveTournamentOutputDTO } from './tournament.validation';
+export declare class TournamentService {
+    private repository;
+    constructor();
+    getActive(): Promise<ActiveTournamentOutputDTO | null>;
+}
+export declare const tournamentService: TournamentService;
+//# sourceMappingURL=tournament.service.d.ts.map

package/dist/lib/modules/tournament/tournament.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.service.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAGpE,qBACa,iBAAiB;IAC7B,OAAO,CAAC,UAAU,CAA6B;;IAMlC,SAAS,IAAI,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;CAGnE;AAED,eAAO,MAAM,iBAAiB,mBAAmC,CAAC"}

package/dist/lib/modules/tournament/tournament.service.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tournamentService = exports.TournamentService = void 0;
+const typedi_1 = __importStar(require("typedi"));
+const config_repository_1 = require("./config/config.repository");
+let TournamentService = class TournamentService {
+    repository;
+    constructor() {
+        this.repository = typedi_1.default.get(config_repository_1.TournamentConfigRepository);
+    }
+    async getActive() {
+        return this.repository.findActive();
+    }
+};
+exports.TournamentService = TournamentService;
+exports.TournamentService = TournamentService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], TournamentService);
+exports.tournamentService = typedi_1.default.get(TournamentService);
+//# sourceMappingURL=tournament.service.js.map

package/dist/lib/modules/tournament/tournament.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.service.js","sourceRoot":"/","sources":["modules/tournament/tournament.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAA4C;AAE5C,kEAAwE;AAGjE,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IACrB,UAAU,CAA6B;IAE/C;QACC,IAAI,CAAC,UAAU,GAAG,gBAAS,CAAC,GAAG,CAAC,8CAA0B,CAAC,CAAC;IAC7D,CAAC;IAEM,KAAK,CAAC,SAAS;QACrB,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,EAA+C,CAAC;IAClF,CAAC;CACD,CAAA;AAVY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,gBAAO,GAAE;;GACG,iBAAiB,CAU7B;AAEY,QAAA,iBAAiB,GAAG,gBAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC","sourcesContent":["import Container, { Service } from 'typedi';\nimport { ActiveTournamentOutputDTO } from './tournament.validation';\nimport { TournamentConfigRepository } from './config/config.repository';\n\n@Service()\nexport class TournamentService {\n\tprivate repository: TournamentConfigRepository;\n\n\tconstructor() {\n\t\tthis.repository = Container.get(TournamentConfigRepository);\n\t}\n\n\tpublic async getActive(): Promise<ActiveTournamentOutputDTO | null> {\n\t\treturn this.repository.findActive() as Promise<ActiveTournamentOutputDTO | null>;\n\t}\n}\n\nexport const tournamentService = Container.get(TournamentService);\n"]}

package/dist/lib/modules/tournament/tournament.validation.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+export declare const ActiveTournamentSchema: z.ZodObject<{
+    name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    tag: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    startDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    endDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    tag: string;
+    startDate?: Date | null | undefined;
+    endDate?: Date | null | undefined;
+}, {
+    name: string;
+    tag: string;
+    startDate?: Date | null | undefined;
+    endDate?: Date | null | undefined;
+}>;
+export declare const ActiveTournamentResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            name: string;
+            tag: string;
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        } | null, z.ZodTypeDef, {
+            name: string;
+            tag: string;
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        } | null>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: ({
+            name: string;
+            tag: string;
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: ({
+            name: string;
+            tag: string;
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        name: string;
+        tag: string;
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | null, z.ZodTypeDef, {
+        name: string;
+        tag: string;
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | null>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        name: string;
+        tag: string;
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | {
+        documents: ({
+            name: string;
+            tag: string;
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | null | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        name: string;
+        tag: string;
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | {
+        documents: ({
+            name: string;
+            tag: string;
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | null | undefined;
+}>;
+export type ActiveTournamentOutputDTO = DTO<typeof ActiveTournamentSchema>;
+//# sourceMappingURL=tournament.validation.d.ts.map

package/dist/lib/modules/tournament/tournament.validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAG/F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0D,CAAC;AAEtG,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/lib/modules/tournament/tournament.validation.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveTournamentResponseSchema = exports.ActiveTournamentSchema = void 0;
+const zod_1 = require("zod");
+const global_validation_1 = require("@lyxa.ai/core/dist/utilities/validation/global-validation");
+const validation_1 = require("@lyxa.ai/core/dist/utilities/validation");
+exports.ActiveTournamentSchema = zod_1.z.object({
+    name: global_validation_1.ZodValidation.string('Tournament name'),
+    tag: global_validation_1.ZodValidation.string('Tournament tag'),
+    startDate: zod_1.z.date().nullable().optional(),
+    endDate: zod_1.z.date().nullable().optional(),
+});
+exports.ActiveTournamentResponseSchema = (0, validation_1.createResponseSchema)(exports.ActiveTournamentSchema.nullable());
+//# sourceMappingURL=tournament.validation.js.map

package/dist/lib/modules/tournament/tournament.validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.validation.js","sourceRoot":"/","sources":["modules/tournament/tournament.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAElE,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,iCAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAC7C,GAAG,EAAE,iCAAa,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAC3C,SAAS,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACzC,OAAO,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACvC,CAAC,CAAC;AAEU,QAAA,8BAA8B,GAAG,IAAA,iCAAoB,EAAC,8BAAsB,CAAC,QAAQ,EAAE,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { DTO, ZodValidation } from '@lyxa.ai/core/dist/utilities/validation/global-validation';\nimport { createResponseSchema } from '@lyxa.ai/core/dist/utilities/validation';\n\nexport const ActiveTournamentSchema = z.object({\n\tname: ZodValidation.string('Tournament name'),\n\ttag: ZodValidation.string('Tournament tag'),\n\tstartDate: z.date().nullable().optional(),\n\tendDate: z.date().nullable().optional(),\n});\n\nexport const ActiveTournamentResponseSchema = createResponseSchema(ActiveTournamentSchema.nullable());\n\nexport type ActiveTournamentOutputDTO = DTO<typeof ActiveTournamentSchema>;\n"]}

package/dist/types/event/event-initializations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-initializations.d.ts","sourceRoot":"/","sources":["event/event-initializations.ts"],"names":[],"mappings":"AAOA,wBAAsB,kBAAkB,kBAKvC"}
+{"version":3,"file":"event-initializations.d.ts","sourceRoot":"/","sources":["event/event-initializations.ts"],"names":[],"mappings":"AAQA,wBAAsB,kBAAkB,kBAMvC"}

package/dist/types/events/event-initializations.d.ts

@@ -0,0 +1,2 @@
+export declare function initEventSystem(): Promise<void>;
+//# sourceMappingURL=event-initializations.d.ts.map

package/dist/types/events/event-initializations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-initializations.d.ts","sourceRoot":"/","sources":["events/event-initializations.ts"],"names":[],"mappings":"AACA,wBAAsB,eAAe,kBAAK"}