@purpleschool/gptbot 0.6.15 → 0.6.16

package/build/commands/index.js

@@ -50,3 +50,4 @@ __exportStar(require("./prompt-category"), exports);
 __exportStar(require("./prompt-topic"), exports);
 __exportStar(require("./prompt"), exports);
 __exportStar(require("./folder"), exports);
+__exportStar(require("./user-to-product"), exports);

package/build/commands/user/find-users-by-criteria.command.js

@@ -9,24 +9,54 @@ const models_1 = require("../../models");
 const constants_1 = require("../../constants");
 var FindUsersByCriteriaCommand;
 (function (FindUsersByCriteriaCommand) {
-    FindUsersByCriteriaCommand.RequestSchema = zod_1.default
-        .object({
+    FindUsersByCriteriaCommand.RequestSchema = zod_1.default.preprocess((input) => {
+        if (input && typeof input === 'object' && !Array.isArray(input)) {
+            const obj = Object.assign({}, input);
+            const onlyNormalize = ['createdAt', 'updatedAt', 'tokenBonusBalance'];
+            const relevantBracketed = Object.keys(obj).some((key) => {
+                const match = key.match(/^(\w+)\[(\w+)\]$/);
+                return match && onlyNormalize.includes(match[1]);
+            });
+            if (!relevantBracketed) {
+                return obj;
+            }
+            const result = Object.assign({}, obj);
+            for (const key of Object.keys(obj)) {
+                const match = key.match(/^(\w+)\[(\w+)\]$/);
+                if (match && onlyNormalize.includes(match[1])) {
+                    const [, outer, inner] = match;
+                    result[outer] = result[outer] || {};
+                    result[outer][inner] = obj[key];
+                    delete result[key];
+                }
+            }
+            return result;
+        }
+        return input;
+    }, zod_1.default.object({
         uuid: zod_1.default.string().uuid().optional(),
         email: zod_1.default.string().email().optional(),
         status: zod_1.default.nativeEnum(constants_1.USER_STATUS).optional(),
         role: zod_1.default.nativeEnum(constants_1.ROLE).optional(),
-        createdAt: zod_1.default.date().optional(),
-        updatedAt: zod_1.default.date().optional(),
+        telegramId: zod_1.default.coerce.number().optional(),
+        createdAt: models_1.DateFilter.optional(),
+        updatedAt: models_1.DateFilter.optional(),
+        tokenBonusBalance: models_1.NumberFilter.optional(),
         sortBy: zod_1.default.nativeEnum(constants_1.USER_SORT_BY).optional(),
         sortOrder: zod_1.default.nativeEnum(constants_1.SORT_ORDER).default(constants_1.SORT_ORDER.DESC).optional(),
-    })
-        .partial();
+        limit: zod_1.default.coerce.number().min(1),
+        offset: zod_1.default.coerce.number().min(0).default(0),
+    }));
     FindUsersByCriteriaCommand.ResponseSchema = zod_1.default.object({
         data: zod_1.default.array(models_1.UserSchema.omit({
             verifyTokenHash: true,
             password: true,
             passwordHash: true,
             restoreTokenHash: true,
+        }).extend({
+            telegramId: zod_1.default.number().nullable(),
         })),
+        page: zod_1.default.number(),
+        totalPages: zod_1.default.number(),
     });
 })(FindUsersByCriteriaCommand || (exports.FindUsersByCriteriaCommand = FindUsersByCriteriaCommand = {}));

package/build/commands/user-to-product/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./update-user-to-product.command"), exports);

package/build/commands/user-to-product/update-user-to-product.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateUserToProductCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var UpdateUserToProductCommand;
+(function (UpdateUserToProductCommand) {
+    UpdateUserToProductCommand.RequestParamSchema = models_1.UserToProductSchema.pick({
+        uuid: true,
+    });
+    UpdateUserToProductCommand.RequestSchema = models_1.UserToProductSchema.pick({
+        initTokenBalance: true,
+        tokenBalance: true,
+        status: true,
+    }).partial();
+    UpdateUserToProductCommand.ResponseSchema = zod_1.z.object({
+        data: UpdateUserToProductCommand.RequestParamSchema,
+    });
+})(UpdateUserToProductCommand || (exports.UpdateUserToProductCommand = UpdateUserToProductCommand = {}));

package/build/commands/user-to-subscription/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./get-user-to-subscriptions.command"), exports);
+__exportStar(require("./update-user-to-subscription.command"), exports);

package/build/commands/user-to-subscription/update-user-to-subscription.command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateUserToSubscriptionCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var UpdateUserToSubscriptionCommand;
+(function (UpdateUserToSubscriptionCommand) {
+    UpdateUserToSubscriptionCommand.RequestParamSchema = models_1.UserToSubscriptionSchema.pick({
+        uuid: true,
+    });
+    UpdateUserToSubscriptionCommand.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid(),
+        subscriptionId: zod_1.z.string(),
+        initTokenBalance: zod_1.z.number(),
+        active: zod_1.z.coerce.boolean(),
+        tokenBalance: zod_1.z.number(),
+        status: zod_1.z.string(),
+        endDate: zod_1.z.coerce.date().nullable(),
+        marks: zod_1.z.array(zod_1.z.string()),
+        intervalEndDate: zod_1.z.coerce.date().nullable(),
+    })
+        .partial();
+    UpdateUserToSubscriptionCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.UserToSubscriptionSchema,
+    });
+})(UpdateUserToSubscriptionCommand || (exports.UpdateUserToSubscriptionCommand = UpdateUserToSubscriptionCommand = {}));

package/build/models/filters.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberFilter = exports.DateFilter = void 0;
+const zod_1 = require("zod");
+exports.DateFilter = zod_1.z.object({
+    gt: zod_1.z.coerce.date().optional(),
+    gte: zod_1.z.coerce.date().optional(),
+    lt: zod_1.z.coerce.date().optional(),
+    lte: zod_1.z.coerce.date().optional(),
+});
+exports.NumberFilter = zod_1.z.object({
+    gt: zod_1.z.coerce.number().optional(),
+    gte: zod_1.z.coerce.number().optional(),
+    lt: zod_1.z.coerce.number().optional(),
+    lte: zod_1.z.coerce.number().optional(),
+});

package/build/models/index.js

@@ -62,3 +62,4 @@ __exportStar(require("./prompt-category.schema"), exports);
 __exportStar(require("./prompt-topic.schema"), exports);
 __exportStar(require("./prompt.schema"), exports);
 __exportStar(require("./folder.schema"), exports);
+__exportStar(require("./filters.schema"), exports);

package/commands/index.ts

@@ -34,3 +34,4 @@ export * from './prompt-category';
 export * from './prompt-topic';
 export * from './prompt';
 export * from './folder';
+export * from './user-to-product';

package/commands/user/find-users-by-criteria.command.ts

@@ -1,21 +1,55 @@
 import z from 'zod';
-import { UserSchema } from '../../models';
+import { DateFilter, NumberFilter, UserSchema } from '../../models';
 import { ROLE, SORT_ORDER, USER_SORT_BY, USER_STATUS } from '../../constants';
 
 export namespace FindUsersByCriteriaCommand {
-    export const RequestSchema = z
-        .object({
+    export const RequestSchema = z.preprocess(
+        (input) => {
+            if (input && typeof input === 'object' && !Array.isArray(input)) {
+                const obj = { ...input } as Record<string, any>;
+                const onlyNormalize = ['createdAt', 'updatedAt', 'tokenBonusBalance'];
+
+                const relevantBracketed = Object.keys(obj).some((key) => {
+                    const match = key.match(/^(\w+)\[(\w+)\]$/);
+                    return match && onlyNormalize.includes(match[1]);
+                });
+
+                if (!relevantBracketed) {
+                    return obj;
+                }
+
+                const result = { ...obj };
+                for (const key of Object.keys(obj)) {
+                    const match = key.match(/^(\w+)\[(\w+)\]$/);
+                    if (match && onlyNormalize.includes(match[1])) {
+                        const [, outer, inner] = match;
+                        result[outer] = result[outer] || {};
+                        result[outer][inner] = obj[key];
+                        delete result[key];
+                    }
+                }
+                return result;
+            }
+            return input;
+        },
+        z.object({
             uuid: z.string().uuid().optional(),
             email: z.string().email().optional(),
             status: z.nativeEnum(USER_STATUS).optional(),
             role: z.nativeEnum(ROLE).optional(),
-            createdAt: z.date().optional(),
-            updatedAt: z.date().optional(),
+            telegramId: z.coerce.number().optional(),
+
+            createdAt: DateFilter.optional(),
+            updatedAt: DateFilter.optional(),
+            tokenBonusBalance: NumberFilter.optional(),
 
             sortBy: z.nativeEnum(USER_SORT_BY).optional(),
             sortOrder: z.nativeEnum(SORT_ORDER).default(SORT_ORDER.DESC).optional(),
-        })
-        .partial();
+
+            limit: z.coerce.number().min(1),
+            offset: z.coerce.number().min(0).default(0),
+        }),
+    );
 
     export type Request = z.infer<typeof RequestSchema>;
 
@@ -26,8 +60,12 @@ export namespace FindUsersByCriteriaCommand {
                 password: true,
                 passwordHash: true,
                 restoreTokenHash: true,
+            }).extend({
+                telegramId: z.number().nullable(),
             }),
         ),
+        page: z.number(),
+        totalPages: z.number(),
     });
 
     export type Response = z.infer<typeof ResponseSchema>;

package/commands/user-to-product/index.ts

@@ -0,0 +1 @@
+export * from './update-user-to-product.command';

package/commands/user-to-product/update-user-to-product.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { UserToProductSchema } from '../../models';
+
+export namespace UpdateUserToProductCommand {
+    export const RequestParamSchema = UserToProductSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = UserToProductSchema.pick({
+        initTokenBalance: true,
+        tokenBalance: true,
+        status: true,
+    }).partial();
+
+    export const ResponseSchema = z.object({
+        data: RequestParamSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/user-to-subscription/index.ts

@@ -1 +1,2 @@
 export * from './get-user-to-subscriptions.command';
+export * from './update-user-to-subscription.command';

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { UserToSubscriptionSchema } from '../../models';
+
+export namespace UpdateUserToSubscriptionCommand {
+    export const RequestParamSchema = UserToSubscriptionSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid(),
+            subscriptionId: z.string(),
+            initTokenBalance: z.number(),
+            active: z.coerce.boolean(),
+            tokenBalance: z.number(),
+            status: z.string(),
+            endDate: z.coerce.date().nullable(),
+            marks: z.array(z.string()),
+            intervalEndDate: z.coerce.date().nullable(),
+        })
+        .partial();
+
+    export const ResponseSchema = z.object({
+        data: UserToSubscriptionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/models/filters.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export const DateFilter = z.object({
+    gt: z.coerce.date().optional(),
+    gte: z.coerce.date().optional(),
+    lt: z.coerce.date().optional(),
+    lte: z.coerce.date().optional(),
+});
+export type DateFilter = z.infer<typeof DateFilter>;
+
+export const NumberFilter = z.object({
+    gt: z.coerce.number().optional(),
+    gte: z.coerce.number().optional(),
+    lt: z.coerce.number().optional(),
+    lte: z.coerce.number().optional(),
+});
+export type NumberFilter = z.infer<typeof NumberFilter>;

package/models/index.ts

@@ -46,3 +46,4 @@ export * from './prompt-category.schema';
 export * from './prompt-topic.schema';
 export * from './prompt.schema';
 export * from './folder.schema';
+export * from './filters.schema';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",