pangea-server 3.3.81 → 3.3.83

package/dist/auth/access-token.class.d.ts

@@ -6,8 +6,10 @@ export declare class AccessToken {
     getKey(userCtor: UserCtor): string;
     createToken(userCtor: UserCtor, id: ModelId): string;
     verifyToken(token: string): Record<string, ModelId>;
-    getTokenData(userCtor: UserCtor, user: User): {
+    getTokenData(userCtor: UserCtor, user: ModelInstance<User>): {
         accessToken: string;
-        user: User;
+        user: import("sequelize").InferAttributes<User, {
+            omit: never;
+        }>;
     };
 }

package/dist/auth/auth.helpers.d.ts

@@ -4,14 +4,22 @@ import type { UserCtor, AuthMap } from './auth.types';
 type AuthHeader = string | undefined;
 export declare function login<U extends User>(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: BaseModelCtor<U>, extraWhere?: Where<U>): Promise<{
     accessToken: string;
-    user: User;
+    user: import("sequelize").InferAttributes<User, {
+        omit: never;
+    }>;
 }>;
 export declare function validateAccessToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: UserCtor): Promise<{
     accessToken: string;
-    user: User;
+    user: import("sequelize").InferAttributes<User, {
+        omit: never;
+    }>;
 }>;
-export declare function getUserFromToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: UserCtor): Promise<User | null> | null;
+export declare function getUserFromToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: UserCtor): Promise<import("sequelize").InferAttributes<User, {
+    omit: never;
+}> | null> | null;
 export declare function getUsersFromToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, authMap: AuthMap): Promise<{
-    [k: string]: User | null;
+    [k: string]: import("sequelize").InferAttributes<User, {
+        omit: never;
+    }> | null;
 }>;
 export {};

package/dist/auth/auth.types.d.ts

@@ -4,7 +4,7 @@ export type UserCtor = BaseModelCtor<User>;
 export type AuthMap = Record<string, UserCtor>;
 export type UserType<AM extends AuthMap> = keyof AM;
 export type AuthUsers<AM extends AuthMap> = {
-    [K in keyof AM]: InstanceType<AM[K]> | null;
+    [K in keyof AM]: ModelInstance<InstanceType<AM[K]>> | null;
 };
 export interface AuthCtor<AM extends AuthMap, AU extends AuthUsers<AM>, BA extends BaseAuth<AM>, IR extends any> {
     new (authUsers: AU, initRes?: IR): BA;

package/dist/auth/base-auth.class.d.ts

@@ -7,5 +7,7 @@ export declare abstract class BaseAuth<AM extends AuthMap> {
     notAllowed(): never;
     isUserAuth<T extends UserType<AM>>(type: T): boolean;
     getUserAuth<T extends UserType<AM>>(type: T): NonNullable<AuthUsers<AM>[T]>;
-    getUsersAuth<const T extends readonly UserType<AM>[]>(types: T): { [I in keyof T]: InstanceType<AM[T[I]]> | null; };
+    getUsersAuth<const T extends readonly UserType<AM>[]>(types: T): { [I in keyof T]: import("sequelize").InferAttributes<InstanceType<AM[T[I]]>, {
+        omit: never;
+    }> | null; };
 }

package/dist/database/database.types.d.ts

@@ -2,7 +2,7 @@ import * as seq from 'sequelize-typescript';
 import { BaseModel } from './models';
 import { Db as _Db } from './db.class';
 import type { OptionalFields, OptionalIfNullish } from 'pangea-helpers';
-import type { InferCreationAttributes, CreationOptional, NonAttribute, AbstractDataTypeConstructor, AbstractDataType, Transaction, WhereOptions } from 'sequelize';
+import type { InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, AbstractDataTypeConstructor, AbstractDataType, Transaction, WhereOptions } from 'sequelize';
 import type { ModelCtor } from 'sequelize-typescript';
 declare global {
     type ModelId = number;
@@ -16,6 +16,10 @@ declare global {
     type Where<BM extends BaseModel> = WhereOptions<BM> & Record<symbol, any>;
     type InsertParams<BM extends BaseModel> = OptionalIfNullish<OptionalIfOptional<StripRelations<OptionalFields<IncludeHidden<Omit<InferCreationAttributes<BM>, '__brand'>>, Exclude<keyof InferCreationAttributes<BM>, '__brand'> & 'id'>>>>;
     type UpdateParams<BM extends BaseModel> = Partial<InsertParams<BM>>;
+    type UpdateParamsWithId<BM extends BaseModel> = UpdateParams<BM> & {
+        id: ModelId;
+    };
+    type ModelInstance<BM extends BaseModel> = InferAttributes<BM>;
     type Tx = Transaction;
     type Db = _Db;
 }

package/dist/database/db.class.d.ts

@@ -33,36 +33,51 @@ type AggregateManyConfig = {
     group: Group;
 };
 type AggregateManyOptions<BM extends BaseModel> = Omit<FindManyOptions<BM>, 'order'>;
-type Target<BM extends BaseModel> = Filters<BM> | BM;
 export declare class Db {
     private __tx?;
     constructor(tx: Tx);
-    findOneOrNull<BM extends BaseModel>(model: BaseModelCtor<BM>, filters: Filters<BM>, options?: FindOneOptions): Promise<BM | null>;
-    findOne<BM extends BaseModel>(model: BaseModelCtor<BM>, filters: Filters<BM>, options?: FindOneOptions): Promise<BM>;
+    findOneOrNull<BM extends BaseModel>(model: BaseModelCtor<BM>, filters: Filters<BM>, options?: FindOneOptions): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }> | null>;
+    findOne<BM extends BaseModel>(model: BaseModelCtor<BM>, filters: Filters<BM>, options?: FindOneOptions): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }>>;
     aggregateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, attributes: Attributes, options?: AggregateOneOptions<BM>): Promise<unknown>;
     private __getFindOneBaseOptions;
-    findMany<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyPagedOptions<BM>): Promise<BM[]>;
+    findMany<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyPagedOptions<BM>): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }>[]>;
     count<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyOptions<BM>): Promise<number>;
     findManyWithCount<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyPagedOptions<BM>): Promise<{
-        instances: BM[];
+        instances: import("sequelize").InferAttributes<BM, {
+            omit: never;
+        }>[];
         totalCount: number;
     }>;
     aggregateMany<BM extends BaseModel>(model: BaseModelCtor<BM>, config: AggregateManyConfig, options?: AggregateManyOptions<BM>): Promise<unknown[]>;
     private __getFindManyBaseOptions;
-    insertOne<BM extends BaseModel>(model: BaseModelCtor<BM>, params: InsertParams<BM>): Promise<BM>;
+    insertOne<BM extends BaseModel>(model: BaseModelCtor<BM>, params: InsertParams<BM>): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }>>;
     insertMany<BM extends BaseModel>(model: BaseModelCtor<BM>, data: InsertParams<BM>[]): Promise<number>;
     upsertMany<BM extends BaseModel>(model: BaseModelCtor<BM>, fieldsToUpdate: (keyof BM)[], data: InsertParams<BM>[]): Promise<number>;
-    updateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>, params: UpdateParams<BM>): Promise<BM>;
+    updateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, params: UpdateParamsWithId<BM>): Promise<ModelInstance<BM>>;
+    updateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId, params: UpdateParams<BM>): Promise<ModelInstance<BM>>;
     updateMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>, params: UpdateParams<BM>): Promise<number>;
-    deleteOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM | null>;
+    deleteOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }> | null>;
     deleteMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<number>;
-    destroyOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM | null>;
+    destroyOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }> | null>;
     destroyMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<number>;
     private __deleteOne;
     private __deleteMany;
-    restoreOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM>;
+    restoreOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId): Promise<import("sequelize").InferAttributes<BM, {
+        omit: never;
+    }>>;
     restoreMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<void>;
-    private __getInstance;
     query(sql: string | {
         query: string;
         values: unknown[];

package/dist/database/db.class.js

@@ -13,18 +13,24 @@ class Db {
         this.__tx = tx;
     }
     // find methods
-    findOneOrNull(model, filters, options = {}) {
+    async findOneOrNull(model, filters, options = {}) {
         const { scopes, order, paranoid = true } = options;
         const scopedModel = scopes?.length ? model.scope(...scopes) : model;
         const baseOptions = this.__getFindOneBaseOptions(paranoid);
+        let instance;
         if (typeof filters === 'number') {
-            return scopedModel.findByPk(filters, { ...baseOptions, ...getInclude(model) });
+            instance = await scopedModel.findByPk(filters, { ...baseOptions, ...getInclude(model) });
         }
-        return scopedModel.findOne({
-            ...baseOptions,
-            ...getInclude(model, { where: filters }),
-            order: getFinalOrder(order),
-        });
+        else {
+            instance = await scopedModel.findOne({
+                ...baseOptions,
+                ...getInclude(model, { where: filters }),
+                order: getFinalOrder(order),
+            });
+        }
+        if (!instance)
+            return null;
+        return processInstance(model, instance);
     }
     async findOne(model, filters, options = {}) {
         const instance = await this.findOneOrNull(model, filters, options);
@@ -48,6 +54,7 @@ class Db {
     async findMany(model, options = {}) {
         const baseOptions = this.__getFindManyBaseOptions(model, options);
         const { page, pageSize } = options;
+        let instances;
         if (page && pageSize) {
             const idRows = await model.findAll({
                 ...baseOptions,
@@ -58,9 +65,12 @@ class Db {
                 limit: pageSize,
             });
             const ids = idRows.map((row) => row.id);
-            return model.findAll({ ...baseOptions, where: { id: { [_1.Ops.in]: ids } } });
+            instances = await model.findAll({ ...baseOptions, where: { id: { [_1.Ops.in]: ids } } });
+        }
+        else {
+            instances = await model.findAll(baseOptions);
         }
-        return model.findAll(baseOptions);
+        return processInstances(model, instances);
     }
     async count(model, options = {}) {
         const baseOptions = this.__getFindManyBaseOptions(model, options);
@@ -143,12 +153,12 @@ class Db {
             return newInstances.length;
         });
     }
-    // update methods
-    updateOne(model, target, params) {
+    updateOne(model, idOrParams, params) {
         return handleDbError(async () => {
-            const instance = await this.__getInstance(model, target);
-            await instance.update(params, { transaction: this.__tx });
-            return this.findOne(model, instance.id);
+            const id = typeof idOrParams === 'number' ? idOrParams : idOrParams.id;
+            const finalParams = typeof idOrParams === 'number' ? params : idOrParams;
+            await model.update(finalParams, { where: { id }, transaction: this.__tx });
+            return this.findOne(model, id);
         });
     }
     updateMany(model, where, params) {
@@ -158,23 +168,22 @@ class Db {
         });
     }
     // delete methods
-    deleteOne(model, target) {
-        return this.__deleteOne(model, target, false);
+    deleteOne(model, id) {
+        return this.__deleteOne(model, id, false);
     }
     deleteMany(model, where) {
         return this.__deleteMany(model, where, false);
     }
-    destroyOne(model, target) {
-        return this.__deleteOne(model, target, true);
+    destroyOne(model, id) {
+        return this.__deleteOne(model, id, true);
     }
     destroyMany(model, where) {
         return this.__deleteMany(model, where, true);
     }
-    __deleteOne(model, target, force) {
+    __deleteOne(model, id, force) {
         return handleDbError(async () => {
-            const instance = await this.__getInstance(model, target);
-            await instance.destroy({ force, transaction: this.__tx });
-            return this.findOneOrNull(model, instance.id, { paranoid: false });
+            await model.destroy({ where: { id }, force, transaction: this.__tx });
+            return this.findOneOrNull(model, id, { paranoid: false });
         });
     }
     __deleteMany(model, where, force) {
@@ -183,11 +192,10 @@ class Db {
         });
     }
     // restore methods
-    restoreOne(model, target) {
+    restoreOne(model, id) {
         return handleDbError(async () => {
-            const instance = await this.__getInstance(model, target, false);
-            await instance.restore({ transaction: this.__tx });
-            return this.findOne(model, instance.id);
+            await model.restore({ where: { id }, transaction: this.__tx });
+            return this.findOne(model, id);
         });
     }
     restoreMany(model, where) {
@@ -196,11 +204,6 @@ class Db {
         });
     }
     // helpers methods
-    __getInstance(model, target, paranoid = true) {
-        if (target && typeof target === 'object' && 'id' in target)
-            return target;
-        return this.findOne(model, target, { paranoid });
-    }
     query(sql) {
         const dbClient = (0, db_client_1.getDbClient)();
         return dbClient.query(sql, { transaction: this.__tx });
@@ -301,6 +304,24 @@ function getFinalOrder(order, config = {}) {
     });
     return [...finalOrder, ...(!config.attributes ? [['createdAt', 'DESC']] : [])];
 }
+function processInstance(model, instance) {
+    for (const [relName] of Object.entries(model.Relations)) {
+        const relInstance = instance[relName];
+        if (!relInstance)
+            continue;
+        const relModel = model.Relations[relName].getModelFn();
+        if (Array.isArray(relInstance)) {
+            relInstance.forEach((instance) => processInstance(relModel, instance));
+        }
+        else {
+            processInstance(relModel, relInstance);
+        }
+    }
+    return instance.toJSON();
+}
+function processInstances(model, instances) {
+    return instances.map((instance) => processInstance(model, instance));
+}
 async function handleDbError(operation) {
     try {
         return await operation();

package/dist/router/call-controller.js

@@ -55,19 +55,17 @@ function hasInstancesAndTotalCount(obj) {
     return typeof obj === 'object' && obj !== null && 'instances' in obj && 'totalCount' in obj;
 }
 async function setFilesUrls(data) {
+    const targets = [];
     const visited = new WeakSet();
-    const singleTargets = [];
-    const arrayTargets = [];
-    function isTargetKey(key) {
-        const k = key.toLowerCase();
-        return k.includes('image') || k.includes('video');
-    }
-    function normalizeArray(value) {
-        if (Array.isArray(value))
-            return value;
-        if (typeof value === 'string' && value.length)
-            return value.split(',').map((v) => v.trim()).filter(Boolean);
-        return [];
+    function getFieldMode(key, val) {
+        const lowerKey = key.toLowerCase();
+        if (lowerKey.endsWith('url') || lowerKey.endsWith('urls'))
+            return;
+        if ((lowerKey.endsWith('image') || lowerKey.endsWith('video')) && (typeof val === 'string' || val === null)) {
+            return 'single';
+        }
+        if ((lowerKey.endsWith('images') || lowerKey.endsWith('videos')) && Array.isArray(val))
+            return 'plural';
     }
     function collect(node) {
         if (!node)
@@ -81,62 +79,32 @@ async function setFilesUrls(data) {
         if (visited.has(node))
             return;
         visited.add(node);
-        for (const [key, value] of Object.entries(node)) {
-            if (isTargetKey(key)) {
-                if (Array.isArray(value) || typeof value === 'string') {
-                    const arr = normalizeArray(value);
-                    if (arr.length > 1) {
-                        node[key] = arr;
-                        arrayTargets.push({ node, key });
-                    }
-                    else if (arr.length === 1) {
-                        node[key] = arr[0];
-                        singleTargets.push({ node, key });
-                    }
-                    else if (Array.isArray(value)) {
-                        node[key] = [];
-                        arrayTargets.push({ node, key });
-                    }
-                    else {
-                        node[key] = null;
-                        singleTargets.push({ node, key });
-                    }
-                }
-            }
-            collect(value);
-        }
+        Object.entries(node).forEach(([key, val]) => {
+            const mode = getFieldMode(key, val);
+            if (mode)
+                targets.push({ obj: node, key, mode });
+            collect(val);
+        });
     }
     collect(data);
-    const filesSet = new Set();
-    singleTargets.forEach(({ node, key }) => {
-        const val = node[key];
-        if (typeof val === 'string' && val.length)
-            filesSet.add(val);
-    });
-    arrayTargets.forEach(({ node, key }) => {
-        const arr = node[key];
-        if (!Array.isArray(arr))
-            return;
-        arr.forEach((v) => {
-            if (typeof v === 'string' && v.length)
-                filesSet.add(v);
-        });
-    });
-    const files = Array.from(filesSet);
-    if (!files.length) {
-        arrayTargets.forEach(({ node, key }) => (node[`${key}Urls`] = []));
-        singleTargets.forEach(({ node, key }) => (node[`${key}Url`] = null));
+    if (!targets.length)
         return;
-    }
-    const urls = await Promise.all(files.map((file) => helpers_1.FileStorage.GenerateDownloadUrl(file)));
+    const allFiles = Array.from(new Set(targets.flatMap(({ obj, key, mode }) => {
+        const val = obj[key];
+        if (val === null)
+            return [];
+        return mode === 'single' ? [val] : val;
+    })));
     const map = new Map();
-    files.forEach((file, i) => map.set(file, urls[i]));
-    singleTargets.forEach(({ node, key }) => {
-        const val = node[key];
-        node[`${key}Url`] = typeof val === 'string' && val.length ? map.get(val) || null : null;
-    });
-    arrayTargets.forEach(({ node, key }) => {
-        const arr = node[key];
-        node[`${key}Urls`] = Array.isArray(arr) ? arr.map((v) => (v && map.has(v) ? map.get(v) : null)) : [];
+    if (allFiles.length) {
+        const urls = await Promise.all(allFiles.map((file) => helpers_1.FileStorage.GenerateDownloadUrl(file)));
+        allFiles.forEach((file, i) => map.set(file, urls[i]));
+    }
+    targets.forEach(({ obj, key, mode }) => {
+        if (mode === 'single') {
+            obj[`${key}Url`] = map.get(obj[key]) || null;
+            return;
+        }
+        obj[`${key}Urls`] = obj[key].map((file) => map.get(file));
     });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pangea-server",
   "description": "",
-  "version": "3.3.81",
+  "version": "3.3.83",
   "files": [
     "dist"
   ],