@purpleschool/multisite 0.0.18 → 0.0.20

package/build/queries/user/find-users.command.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { USER_ROLE, USER_STATUS } from '../../constants';
+export declare namespace FindUsersCommand {
+    const RequestQuerySchema: z.ZodObject<{
+        uuid: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodNativeEnum<typeof USER_ROLE>>;
+        status: z.ZodOptional<z.ZodNativeEnum<typeof USER_STATUS>>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        email?: string | undefined;
+        uuid?: string | undefined;
+        role?: USER_ROLE | undefined;
+        status?: USER_STATUS | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        email?: string | undefined;
+        uuid?: string | undefined;
+        role?: USER_ROLE | undefined;
+        status?: USER_STATUS | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    type RequestQuery = z.infer<typeof RequestQuerySchema>;
+    const ResponseItemSchema: z.ZodObject<{
+        uuid: z.ZodString;
+        email: z.ZodString;
+        role: z.ZodNativeEnum<typeof USER_ROLE>;
+        status: z.ZodNativeEnum<typeof USER_STATUS>;
+        siteId: z.ZodString;
+        tokenBonusBalance: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        uuid: string;
+        siteId: string;
+        role: USER_ROLE;
+        status: USER_STATUS;
+        tokenBonusBalance: number;
+    }, {
+        email: string;
+        uuid: string;
+        siteId: string;
+        role: USER_ROLE;
+        status: USER_STATUS;
+        tokenBonusBalance: number;
+    }>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            email: z.ZodString;
+            role: z.ZodNativeEnum<typeof USER_ROLE>;
+            status: z.ZodNativeEnum<typeof USER_STATUS>;
+            siteId: z.ZodString;
+            tokenBonusBalance: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }, {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }>, "many">;
+        totalPages: z.ZodNumber;
+        page: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        page: number;
+        data: {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }[];
+        totalPages: number;
+    }, {
+        page: number;
+        data: {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }[];
+        totalPages: number;
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=find-users.command.d.ts.map

package/build/queries/user/find-users.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-users.command.d.ts","sourceRoot":"","sources":["../../../queries/user/find-users.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEzD,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;MAO7B,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAEvD,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;MAO7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/user/find-users.command.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindUsersCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+var FindUsersCommand;
+(function (FindUsersCommand) {
+    FindUsersCommand.RequestQuerySchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().optional(),
+        email: zod_1.z.string().email().optional(),
+        role: zod_1.z.nativeEnum(constants_1.USER_ROLE).optional(),
+        status: zod_1.z.nativeEnum(constants_1.USER_STATUS).optional(),
+        limit: zod_1.z.coerce.number().int().min(1).default(20).optional(),
+        offset: zod_1.z.coerce.number().int().min(0).default(0).optional(),
+    });
+    FindUsersCommand.ResponseItemSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        email: zod_1.z.string().email(),
+        role: zod_1.z.nativeEnum(constants_1.USER_ROLE),
+        status: zod_1.z.nativeEnum(constants_1.USER_STATUS),
+        siteId: zod_1.z.string().uuid(),
+        tokenBonusBalance: zod_1.z.number().int(),
+    });
+    FindUsersCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.array(FindUsersCommand.ResponseItemSchema),
+        totalPages: zod_1.z.number().int(),
+        page: zod_1.z.number().int(),
+    });
+})(FindUsersCommand || (exports.FindUsersCommand = FindUsersCommand = {}));

package/build/queries/user/get-all-users.command.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { USER_ROLE, USER_STATUS } from '../../constants';
+export declare namespace GetAllUsersCommand {
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            email: z.ZodString;
+            role: z.ZodNativeEnum<typeof USER_ROLE>;
+            status: z.ZodNativeEnum<typeof USER_STATUS>;
+            siteId: z.ZodString;
+            tokenBonusBalance: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }, {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }[];
+    }, {
+        data: {
+            email: string;
+            uuid: string;
+            siteId: string;
+            role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-all-users.command.d.ts.map

package/build/queries/user/get-all-users.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-all-users.command.d.ts","sourceRoot":"","sources":["../../../queries/user/get-all-users.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEzD,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAWzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/user/get-all-users.command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAllUsersCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+var GetAllUsersCommand;
+(function (GetAllUsersCommand) {
+    GetAllUsersCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.array(zod_1.z.object({
+            uuid: zod_1.z.string().uuid(),
+            email: zod_1.z.string().email(),
+            role: zod_1.z.nativeEnum(constants_1.USER_ROLE),
+            status: zod_1.z.nativeEnum(constants_1.USER_STATUS),
+            siteId: zod_1.z.string().uuid(),
+            tokenBonusBalance: zod_1.z.number().int(),
+        })),
+    });
+})(GetAllUsersCommand || (exports.GetAllUsersCommand = GetAllUsersCommand = {}));

package/build/queries/user/get-my-subscriptions.command.d.ts

@@ -9,6 +9,7 @@ export declare namespace GetMySubscriptionsCommand {
             carriedOverTokenBalance: z.ZodNumber;
             status: z.ZodNativeEnum<typeof USER_TO_SUBSCRIPTION_STATUS>;
             active: z.ZodBoolean;
+            endDate: z.ZodNullable<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
             createdAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
             subscription: z.ZodObject<{
                 uuid: z.ZodString;
@@ -86,6 +87,7 @@ export declare namespace GetMySubscriptionsCommand {
                 discount: number;
                 carryoverPercent: number;
             };
+            endDate: string | Date | null;
         }, {
             active: boolean;
             uuid: string;
@@ -110,6 +112,7 @@ export declare namespace GetMySubscriptionsCommand {
                 discount: number;
                 carryoverPercent: number;
             };
+            endDate: string | Date | null;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         data: {
@@ -136,6 +139,7 @@ export declare namespace GetMySubscriptionsCommand {
                 discount: number;
                 carryoverPercent: number;
             };
+            endDate: string | Date | null;
         }[];
     }, {
         data: {
@@ -162,6 +166,7 @@ export declare namespace GetMySubscriptionsCommand {
                 discount: number;
                 carryoverPercent: number;
             };
+            endDate: string | Date | null;
         }[];
     }>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/queries/user/get-my-subscriptions.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-my-subscriptions.command.d.ts","sourceRoot":"","sources":["../../../queries/user/get-my-subscriptions.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAE9D,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAazB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-my-subscriptions.command.d.ts","sourceRoot":"","sources":["../../../queries/user/get-my-subscriptions.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAE9D,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAczB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/user/get-my-subscriptions.command.js

@@ -14,6 +14,7 @@ var GetMySubscriptionsCommand;
             carriedOverTokenBalance: zod_1.z.number().int(),
             status: zod_1.z.nativeEnum(constants_1.USER_TO_SUBSCRIPTION_STATUS),
             active: zod_1.z.boolean(),
+            endDate: zod_1.z.date().or(zod_1.z.string().datetime()).nullable(),
             createdAt: zod_1.z.date().or(zod_1.z.string().datetime()),
             subscription: models_1.SubscriptionSchema,
         })),

package/build/queries/user/get-user-payments.command.d.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { ORDER_STATUS, ORDER_TYPE, PAYMENT_STATUS } from '../../constants';
+export declare namespace GetUserPaymentsCommand {
+    const ResponseItemSchema: z.ZodObject<{
+        uuid: z.ZodString;
+        orderType: z.ZodNativeEnum<typeof ORDER_TYPE>;
+        orderStatus: z.ZodNativeEnum<typeof ORDER_STATUS>;
+        description: z.ZodString;
+        productId: z.ZodNullable<z.ZodString>;
+        productName: z.ZodNullable<z.ZodString>;
+        subscriptionId: z.ZodNullable<z.ZodString>;
+        subscriptionName: z.ZodNullable<z.ZodString>;
+        paymentStatus: z.ZodNativeEnum<typeof PAYMENT_STATUS>;
+        userId: z.ZodString;
+        userEmail: z.ZodString;
+        sum: z.ZodNumber;
+        currency: z.ZodString;
+        updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        description: string;
+        currency: string;
+        updatedAt: string | Date;
+        userId: string;
+        subscriptionId: string | null;
+        sum: number;
+        orderType: ORDER_TYPE;
+        orderStatus: ORDER_STATUS;
+        productId: string | null;
+        productName: string | null;
+        subscriptionName: string | null;
+        paymentStatus: PAYMENT_STATUS;
+        userEmail: string;
+    }, {
+        uuid: string;
+        description: string;
+        currency: string;
+        updatedAt: string | Date;
+        userId: string;
+        subscriptionId: string | null;
+        sum: number;
+        orderType: ORDER_TYPE;
+        orderStatus: ORDER_STATUS;
+        productId: string | null;
+        productName: string | null;
+        subscriptionName: string | null;
+        paymentStatus: PAYMENT_STATUS;
+        userEmail: string;
+    }>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            orderType: z.ZodNativeEnum<typeof ORDER_TYPE>;
+            orderStatus: z.ZodNativeEnum<typeof ORDER_STATUS>;
+            description: z.ZodString;
+            productId: z.ZodNullable<z.ZodString>;
+            productName: z.ZodNullable<z.ZodString>;
+            subscriptionId: z.ZodNullable<z.ZodString>;
+            subscriptionName: z.ZodNullable<z.ZodString>;
+            paymentStatus: z.ZodNativeEnum<typeof PAYMENT_STATUS>;
+            userId: z.ZodString;
+            userEmail: z.ZodString;
+            sum: z.ZodNumber;
+            currency: z.ZodString;
+            updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            description: string;
+            currency: string;
+            updatedAt: string | Date;
+            userId: string;
+            subscriptionId: string | null;
+            sum: number;
+            orderType: ORDER_TYPE;
+            orderStatus: ORDER_STATUS;
+            productId: string | null;
+            productName: string | null;
+            subscriptionName: string | null;
+            paymentStatus: PAYMENT_STATUS;
+            userEmail: string;
+        }, {
+            uuid: string;
+            description: string;
+            currency: string;
+            updatedAt: string | Date;
+            userId: string;
+            subscriptionId: string | null;
+            sum: number;
+            orderType: ORDER_TYPE;
+            orderStatus: ORDER_STATUS;
+            productId: string | null;
+            productName: string | null;
+            subscriptionName: string | null;
+            paymentStatus: PAYMENT_STATUS;
+            userEmail: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            uuid: string;
+            description: string;
+            currency: string;
+            updatedAt: string | Date;
+            userId: string;
+            subscriptionId: string | null;
+            sum: number;
+            orderType: ORDER_TYPE;
+            orderStatus: ORDER_STATUS;
+            productId: string | null;
+            productName: string | null;
+            subscriptionName: string | null;
+            paymentStatus: PAYMENT_STATUS;
+            userEmail: string;
+        }[];
+    }, {
+        data: {
+            uuid: string;
+            description: string;
+            currency: string;
+            updatedAt: string | Date;
+            userId: string;
+            subscriptionId: string | null;
+            sum: number;
+            orderType: ORDER_TYPE;
+            orderStatus: ORDER_STATUS;
+            productId: string | null;
+            productName: string | null;
+            subscriptionName: string | null;
+            paymentStatus: PAYMENT_STATUS;
+            userEmail: string;
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-user-payments.command.d.ts.map

package/build/queries/user/get-user-payments.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-user-payments.command.d.ts","sourceRoot":"","sources":["../../../queries/user/get-user-payments.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE3E,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAe7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/user/get-user-payments.command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUserPaymentsCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+var GetUserPaymentsCommand;
+(function (GetUserPaymentsCommand) {
+    GetUserPaymentsCommand.ResponseItemSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        orderType: zod_1.z.nativeEnum(constants_1.ORDER_TYPE),
+        orderStatus: zod_1.z.nativeEnum(constants_1.ORDER_STATUS),
+        description: zod_1.z.string(),
+        productId: zod_1.z.string().uuid().nullable(),
+        productName: zod_1.z.string().nullable(),
+        subscriptionId: zod_1.z.string().uuid().nullable(),
+        subscriptionName: zod_1.z.string().nullable(),
+        paymentStatus: zod_1.z.nativeEnum(constants_1.PAYMENT_STATUS),
+        userId: zod_1.z.string().uuid(),
+        userEmail: zod_1.z.string().email(),
+        sum: zod_1.z.number(),
+        currency: zod_1.z.string(),
+        updatedAt: zod_1.z.date().or(zod_1.z.string().datetime()),
+    });
+    GetUserPaymentsCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.array(GetUserPaymentsCommand.ResponseItemSchema),
+    });
+})(GetUserPaymentsCommand || (exports.GetUserPaymentsCommand = GetUserPaymentsCommand = {}));

package/build/queries/user/get-user.command.d.ts

@@ -1,22 +1,28 @@
 import { z } from 'zod';
-import { USER_ROLE } from '../../constants';
+import { USER_ROLE, USER_STATUS } from '../../constants';
 export declare namespace GetUserCommand {
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
             uuid: z.ZodString;
             email: z.ZodString;
             role: z.ZodNativeEnum<typeof USER_ROLE>;
+            status: z.ZodNativeEnum<typeof USER_STATUS>;
             siteId: z.ZodString;
+            tokenBonusBalance: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
             email: string;
             uuid: string;
             siteId: string;
             role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
         }, {
             email: string;
             uuid: string;
             siteId: string;
             role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
         }>;
     }, "strip", z.ZodTypeAny, {
         data: {
@@ -24,6 +30,8 @@ export declare namespace GetUserCommand {
             uuid: string;
             siteId: string;
             role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
         };
     }, {
         data: {
@@ -31,6 +39,8 @@ export declare namespace GetUserCommand {
             uuid: string;
             siteId: string;
             role: USER_ROLE;
+            status: USER_STATUS;
+            tokenBonusBalance: number;
         };
     }>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/queries/user/get-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-user.command.d.ts","sourceRoot":"","sources":["../../../queries/user/get-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,yBAAiB,cAAc,CAAC;IACrB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-user.command.d.ts","sourceRoot":"","sources":["../../../queries/user/get-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEzD,yBAAiB,cAAc,CAAC;IACrB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASzB,CAAC;IACH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/queries/user/get-user.command.js

@@ -10,7 +10,9 @@ var GetUserCommand;
             uuid: zod_1.z.string().uuid(),
             email: zod_1.z.string().email(),
             role: zod_1.z.nativeEnum(constants_1.USER_ROLE),
+            status: zod_1.z.nativeEnum(constants_1.USER_STATUS),
             siteId: zod_1.z.string().uuid(),
+            tokenBonusBalance: zod_1.z.number().int(),
         }),
     });
 })(GetUserCommand || (exports.GetUserCommand = GetUserCommand = {}));

package/build/queries/user/index.d.ts

@@ -1,5 +1,8 @@
 export * from './get-user.command';
+export * from './get-all-users.command';
 export * from './get-user-balance.command';
 export * from './get-my-products.command';
 export * from './get-my-subscriptions.command';
+export * from './find-users.command';
+export * from './get-user-payments.command';
 //# sourceMappingURL=index.d.ts.map

package/build/queries/user/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../queries/user/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../queries/user/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC"}

package/build/queries/user/index.js

@@ -15,6 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./get-user.command"), exports);
+__exportStar(require("./get-all-users.command"), exports);
 __exportStar(require("./get-user-balance.command"), exports);
 __exportStar(require("./get-my-products.command"), exports);
 __exportStar(require("./get-my-subscriptions.command"), exports);
+__exportStar(require("./find-users.command"), exports);
+__exportStar(require("./get-user-payments.command"), exports);

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

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

package/commands/subscription/index.ts

@@ -1,3 +1,7 @@
 export * from './buy-subscription.command';
 export * from './fast-buy-subscription.command';
 export * from './cancel-subscription.command';
+export * from './recover-subscription.command';
+export * from './update-subscription.command';
+export * from './delete-subscription.command';
+export * from './refund-subscription.command';

package/commands/subscription/recover-subscription.command.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export namespace RecoverSubscriptionCommand {
+    export const RequestParamSchema = z.object({
+        uuidSiteUserToSubscription: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.void();
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/subscription/refund-subscription.command.ts

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

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { SubscriptionSchema } from '../../models';
+
+export namespace UpdateSubscriptionCommand {
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        name: z.string().min(1).max(200).optional(),
+        description: z.string().min(1).max(2000).optional(),
+        price: z.number().int().min(0).optional(),
+        interval: z.string().max(20).optional(),
+        period: z.number().int().min(1).max(36).optional(),
+        tokens: z.number().int().min(0).optional(),
+        discount: z.number().int().min(0).optional(),
+        features: z
+            .array(
+                z.object({
+                    type: z.string(),
+                    name: z.string(),
+                }),
+            )
+            .optional(),
+        carryoverPercent: z.number().int().min(0).max(100).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SubscriptionSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/cloud-payments/index.ts

@@ -1 +1,2 @@
 export const CLOUD_PAYMENTS_CANCEL = 'https://api.cloudpayments.ru/subscriptions/cancel';
+export const CLOUD_PAYMENTS_REFUND = 'https://api.cloudpayments.ru/payments/refund';

package/constants/errors/errors.ts

@@ -216,6 +216,16 @@ export const ERRORS = {
         code: 'SUBSCRIPTION_006',
         httpCode: 500,
     },
+    SUBSCRIPTION_RECOVER_ERROR: {
+        message: 'Ошибка при восстановлении подписки',
+        code: 'SUBSCRIPTION_007',
+        httpCode: 500,
+    },
+    SUBSCRIPTION_REFUND_ERROR: {
+        message: 'Ошибка при возврате подписки',
+        code: 'SUBSCRIPTION_008',
+        httpCode: 500,
+    },
 
     // ORDER
     ORDER_NOT_FOUND: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/multisite",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Multisite API contracts (DTO schemas, routes, constants)",
   "type": "commonjs",
   "main": "build/index.js",

package/queries/user/find-users.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { USER_ROLE, USER_STATUS } from '../../constants';
+
+export namespace FindUsersCommand {
+    export const RequestQuerySchema = z.object({
+        uuid: z.string().uuid().optional(),
+        email: z.string().email().optional(),
+        role: z.nativeEnum(USER_ROLE).optional(),
+        status: z.nativeEnum(USER_STATUS).optional(),
+        limit: z.coerce.number().int().min(1).default(20).optional(),
+        offset: z.coerce.number().int().min(0).default(0).optional(),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseItemSchema = z.object({
+        uuid: z.string().uuid(),
+        email: z.string().email(),
+        role: z.nativeEnum(USER_ROLE),
+        status: z.nativeEnum(USER_STATUS),
+        siteId: z.string().uuid(),
+        tokenBonusBalance: z.number().int(),
+    });
+
+    export const ResponseSchema = z.object({
+        data: z.array(ResponseItemSchema),
+        totalPages: z.number().int(),
+        page: z.number().int(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}