pangea-server 3.3.70 → 3.3.72

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

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

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

@@ -4,22 +4,14 @@ 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: import("sequelize").InferAttributes<User, {
-        omit: never;
-    }>;
+    user: User;
 }>;
 export declare function validateAccessToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: UserCtor): Promise<{
     accessToken: string;
-    user: import("sequelize").InferAttributes<User, {
-        omit: never;
-    }>;
+    user: User;
 }>;
-export declare function getUserFromToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: UserCtor): Promise<import("sequelize").InferAttributes<User, {
-    omit: never;
-}> | null> | null;
+export declare function getUserFromToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, userCtor: UserCtor): Promise<User | null> | null;
 export declare function getUsersFromToken(authHeader: AuthHeader, db: Db, accessToken: AccessToken, authMap: AuthMap): Promise<{
-    [k: string]: import("sequelize").InferAttributes<User, {
-        omit: never;
-    }> | null;
+    [k: string]: User | 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]: ModelInstance<InstanceType<AM[K]>> | null;
+    [K in keyof AM]: 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,7 +7,5 @@ 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]: import("sequelize").InferAttributes<InstanceType<AM[T[I]]>, {
-        omit: never;
-    }> | null; };
+    getUsersAuth<const T extends readonly UserType<AM>[]>(types: T): { [I in keyof T]: InstanceType<AM[T[I]]> | 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 { InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, AbstractDataTypeConstructor, AbstractDataType, Transaction, WhereOptions } from 'sequelize';
+import type { InferCreationAttributes, CreationOptional, NonAttribute, AbstractDataTypeConstructor, AbstractDataType, Transaction, WhereOptions } from 'sequelize';
 import type { ModelCtor } from 'sequelize-typescript';
 declare global {
     type ModelId = number;
@@ -16,10 +16,6 @@ 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,51 +33,36 @@ 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<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;
-    }>>;
+    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>;
     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<import("sequelize").InferAttributes<BM, {
-        omit: never;
-    }>[]>;
+    findMany<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyPagedOptions<BM>): Promise<BM[]>;
     count<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyOptions<BM>): Promise<number>;
     findManyWithCount<BM extends BaseModel>(model: BaseModelCtor<BM>, options?: FindManyPagedOptions<BM>): Promise<{
-        instances: import("sequelize").InferAttributes<BM, {
-            omit: never;
-        }>[];
+        instances: BM[];
         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<import("sequelize").InferAttributes<BM, {
-        omit: never;
-    }>>;
+    insertOne<BM extends BaseModel>(model: BaseModelCtor<BM>, params: InsertParams<BM>): Promise<BM>;
     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>, params: UpdateParamsWithId<BM>): Promise<ModelInstance<BM>>;
-    updateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId, params: UpdateParams<BM>): Promise<ModelInstance<BM>>;
+    updateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>, params: UpdateParams<BM>): Promise<BM>;
     updateMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>, params: UpdateParams<BM>): Promise<number>;
-    deleteOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId): Promise<import("sequelize").InferAttributes<BM, {
-        omit: never;
-    }> | null>;
+    deleteOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM | null>;
     deleteMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<number>;
-    destroyOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId): Promise<import("sequelize").InferAttributes<BM, {
-        omit: never;
-    }> | null>;
+    destroyOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM | null>;
     destroyMany<BM extends BaseModel>(model: BaseModelCtor<BM>, where: Where<BM>): Promise<number>;
     private __deleteOne;
     private __deleteMany;
-    restoreOne<BM extends BaseModel>(model: BaseModelCtor<BM>, id: ModelId): Promise<import("sequelize").InferAttributes<BM, {
-        omit: never;
-    }>>;
+    restoreOne<BM extends BaseModel>(model: BaseModelCtor<BM>, target: Target<BM>): Promise<BM>;
     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,24 +13,18 @@ class Db {
         this.__tx = tx;
     }
     // find methods
-    async findOneOrNull(model, filters, options = {}) {
+    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') {
-            instance = await scopedModel.findByPk(filters, { ...baseOptions, ...getInclude(model) });
+            return scopedModel.findByPk(filters, { ...baseOptions, ...getInclude(model) });
         }
-        else {
-            instance = await scopedModel.findOne({
-                ...baseOptions,
-                ...getInclude(model, { where: filters }),
-                order: getFinalOrder(order),
-            });
-        }
-        if (!instance)
-            return null;
-        return processInstance(model, instance);
+        return scopedModel.findOne({
+            ...baseOptions,
+            ...getInclude(model, { where: filters }),
+            order: getFinalOrder(order),
+        });
     }
     async findOne(model, filters, options = {}) {
         const instance = await this.findOneOrNull(model, filters, options);
@@ -54,7 +48,6 @@ 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,
@@ -65,12 +58,9 @@ class Db {
                 limit: pageSize,
             });
             const ids = idRows.map((row) => row.id);
-            instances = await model.findAll({ ...baseOptions, where: { id: { [_1.Ops.in]: ids } } });
-        }
-        else {
-            instances = await model.findAll(baseOptions);
+            return model.findAll({ ...baseOptions, where: { id: { [_1.Ops.in]: ids } } });
         }
-        return processInstances(model, instances);
+        return model.findAll(baseOptions);
     }
     async count(model, options = {}) {
         const baseOptions = this.__getFindManyBaseOptions(model, options);
@@ -153,12 +143,12 @@ class Db {
             return newInstances.length;
         });
     }
-    updateOne(model, idOrParams, params) {
+    // update methods
+    updateOne(model, target, params) {
         return handleDbError(async () => {
-            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);
+            const instance = await this.__getInstance(model, target);
+            await instance.update(params, { transaction: this.__tx });
+            return this.findOne(model, instance.id);
         });
     }
     updateMany(model, where, params) {
@@ -168,22 +158,23 @@ class Db {
         });
     }
     // delete methods
-    deleteOne(model, id) {
-        return this.__deleteOne(model, id, false);
+    deleteOne(model, target) {
+        return this.__deleteOne(model, target, false);
     }
     deleteMany(model, where) {
         return this.__deleteMany(model, where, false);
     }
-    destroyOne(model, id) {
-        return this.__deleteOne(model, id, true);
+    destroyOne(model, target) {
+        return this.__deleteOne(model, target, true);
     }
     destroyMany(model, where) {
         return this.__deleteMany(model, where, true);
     }
-    __deleteOne(model, id, force) {
+    __deleteOne(model, target, force) {
         return handleDbError(async () => {
-            await model.destroy({ where: { id }, force, transaction: this.__tx });
-            return this.findOneOrNull(model, id, { paranoid: false });
+            const instance = await this.__getInstance(model, target);
+            await instance.destroy({ force, transaction: this.__tx });
+            return this.findOneOrNull(model, instance.id, { paranoid: false });
         });
     }
     __deleteMany(model, where, force) {
@@ -192,10 +183,11 @@ class Db {
         });
     }
     // restore methods
-    restoreOne(model, id) {
+    restoreOne(model, target) {
         return handleDbError(async () => {
-            await model.restore({ where: { id }, transaction: this.__tx });
-            return this.findOne(model, id);
+            const instance = await this.__getInstance(model, target, false);
+            await instance.restore({ transaction: this.__tx });
+            return this.findOne(model, instance.id);
         });
     }
     restoreMany(model, where) {
@@ -204,6 +196,11 @@ 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 });
@@ -304,24 +301,6 @@ 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

@@ -41,7 +41,7 @@ function callController(controller, validate, appVersion, authConfig) {
             data = result.instances;
             totalCount = result.totalCount;
         }
-        await setImageUrls(data);
+        await setFilesUrls(data);
         const jsonBody = {
             data: data || null,
             totalCount: typeof totalCount === 'number' ? totalCount : null,
@@ -54,8 +54,10 @@ function callController(controller, validate, appVersion, authConfig) {
 function hasInstancesAndTotalCount(obj) {
     return typeof obj === 'object' && obj !== null && 'instances' in obj && 'totalCount' in obj;
 }
-async function setImageUrls(data) {
-    const targets = [];
+async function setFilesUrls(data) {
+    const singularSuffixes = ['Image', 'Video'];
+    const pluralSuffixes = ['Images', 'Videos'];
+    const entries = [];
     const visited = new WeakSet();
     function collect(node) {
         if (!node)
@@ -69,16 +71,43 @@ async function setImageUrls(data) {
         if (visited.has(node))
             return;
         visited.add(node);
-        if (typeof node.image === 'string' && node.image.length)
-            targets.push(node);
+        for (const [key, value] of Object.entries(node)) {
+            if (typeof value === 'string' && value.length) {
+                if (singularSuffixes.some((s) => key === s.toLowerCase() || (key.length > s.length && key.endsWith(s)))) {
+                    entries.push({ node, field: key, type: 'singular' });
+                }
+            }
+            else if (Array.isArray(value) && value.length && value.every((v) => typeof v === 'string')) {
+                if (pluralSuffixes.some((s) => key === s.toLowerCase() || (key.length > s.length && key.endsWith(s)))) {
+                    entries.push({ node, field: key, type: 'plural' });
+                }
+            }
+        }
         Object.values(node).forEach(collect);
     }
     collect(data);
-    if (!targets.length)
+    if (!entries.length)
         return;
-    const uniqueImages = Array.from(new Set(targets.map((target) => target.image)));
-    const urls = await Promise.all(uniqueImages.map((image) => helpers_1.FileStorage.GenerateDownloadUrl(image)));
-    const map = new Map();
-    uniqueImages.forEach((image, i) => map.set(image, urls[i]));
-    targets.forEach((target) => (target.imageUrl = map.get(target.image)));
+    const allFileKeys = new Set();
+    for (const { node, field, type } of entries) {
+        if (type === 'singular') {
+            allFileKeys.add(node[field]);
+        }
+        else {
+            for (const v of node[field])
+                allFileKeys.add(v);
+        }
+    }
+    const uniqueKeys = Array.from(allFileKeys);
+    const urls = await Promise.all(uniqueKeys.map((key) => helpers_1.FileStorage.GenerateDownloadUrl(key)));
+    const urlMap = new Map();
+    uniqueKeys.forEach((key, i) => urlMap.set(key, urls[i]));
+    for (const { node, field, type } of entries) {
+        if (type === 'singular') {
+            node[`${field}Url`] = urlMap.get(node[field]);
+        }
+        else {
+            node[`${field}Urls`] = node[field].map((v) => urlMap.get(v));
+        }
+    }
 }

package/package.json

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