pangea-server 1.0.61 → 1.0.63

package/README.md

@@ -1 +1 @@
-# PANGEA BACKEND
+# PANGEA SERVER

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

@@ -9,16 +9,16 @@ type Group = string[];
 type Order = Record<string, 'asc' | 'desc'>;
 type FindOneOptions = {
     scopes?: string[];
-    attributes?: Attributes;
     order?: Order;
     paranoid?: boolean;
 };
+type AggregateOneOptions = {
+    paranoid?: boolean;
+};
 type FindManyOptions<BM extends BaseModel> = {
-    attributes?: Attributes;
     where?: Where<BM>;
     searchFields?: string[];
     search?: string | null;
-    group?: Group;
     order?: Order;
     paranoid?: boolean;
 };
@@ -26,18 +26,25 @@ type FindManyPagedOptions<BM extends BaseModel> = FindManyOptions<BM> & {
     page?: number | null;
     pageSize?: number | null;
 };
+type AggregateManyConfig = {
+    attributes: Attributes;
+    group: Group;
+};
 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>;
+    aggregateOne<BM extends BaseModel>(model: BaseModelCtor<BM>, attributes: Attributes, options?: AggregateOneOptions): Promise<BM | null>;
+    private __getFindOneBaseOptions;
     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: BM[];
         totalCount: number;
     }>;
+    aggregateMany<BM extends BaseModel>(model: BaseModelCtor<BM>, config: AggregateManyConfig, options?: Omit<FindManyOptions<BM>, 'order'>): Promise<BM[]>;
     private __getFindManyBaseOptions;
     insertOne<BM extends BaseModel>(model: BaseModelCtor<BM>, params: InsertParams<BM>): Promise<BM>;
     insertMany<BM extends BaseModel>(model: BaseModelCtor<BM>, data: InsertParams<BM>[]): Promise<number>;

package/dist/database/db.class.js

@@ -13,20 +13,15 @@ class Db {
     }
     // find methods
     findOneOrNull(model, filters, options = {}) {
-        const { scopes, attributes, order, paranoid = true } = options;
+        const { scopes, order, paranoid = true } = options;
         const scopedModel = scopes?.length ? model.scope(...scopes) : model;
-        const baseOptions = {
-            attributes: getFinalAttributes(model, attributes),
-            paranoid,
-            subQuery: false,
-            transaction: this.__tx,
-        };
+        const baseOptions = this.__getFindOneBaseOptions(paranoid);
         if (typeof filters === 'number') {
             return scopedModel.findByPk(filters, { ...baseOptions, ...getInclude(model) });
         }
         return scopedModel.findOne({
             ...baseOptions,
-            ...getInclude(model, { attributes, where: filters }),
+            ...getInclude(model, { where: filters }),
             order: getFinalOrder(order),
         });
     }
@@ -36,6 +31,18 @@ class Db {
             helpers_1.AppError.ThrowEntityNotFound();
         return instance;
     }
+    aggregateOne(model, attributes, options = {}) {
+        const { paranoid = true } = options;
+        const baseOptions = this.__getFindOneBaseOptions(paranoid);
+        return model.findOne({
+            ...baseOptions,
+            attributes: getFinalAttributes(model, attributes),
+            ...getInclude(model, { attributes }),
+        });
+    }
+    __getFindOneBaseOptions(paranoid) {
+        return { paranoid, subQuery: false, transaction: this.__tx };
+    }
     async findMany(model, options = {}) {
         const baseOptions = this.__getFindManyBaseOptions(model, options);
         const { page, pageSize } = options;
@@ -66,8 +73,16 @@ class Db {
         const instances = await this.findMany(model, options);
         return { instances, totalCount: instances.length };
     }
+    async aggregateMany(model, config, options = {}) {
+        const baseOptions = this.__getFindManyBaseOptions(model, options);
+        return model.findAll({
+            ...baseOptions,
+            attributes: getFinalAttributes(model, config.attributes),
+            ...(config.group && { group: config.group.map((field) => formatField(model.name, field)) }),
+        });
+    }
     __getFindManyBaseOptions(model, options = {}) {
-        const { attributes, where, searchFields, search, group, order, paranoid = true } = options;
+        const { where, searchFields, search, order, paranoid = true } = options;
         let searchWhere;
         if (searchFields?.length && search) {
             const searchWords = search.split(/\s+/).filter(Boolean);
@@ -81,12 +96,7 @@ class Db {
             };
         }
         return {
-            attributes: getFinalAttributes(model, attributes),
-            ...getInclude(model, { attributes, where: { ...where, ...searchWhere } }),
-            ...(group && { group: group.map(pangea_helpers_1.camelToSnake) }),
-            ...(group && {
-                group: group.map((field) => (field.includes('.') ? field : `${model.name}.${(0, pangea_helpers_1.camelToSnake)(field)}`)),
-            }),
+            ...getInclude(model, { where: { ...where, ...searchWhere } }),
             order: getFinalOrder(order),
             paranoid,
             subQuery: false,
@@ -186,17 +196,22 @@ class Db {
 }
 exports.Db = Db;
 // internal functions
+function formatField(modelName, field) {
+    if (field.includes('.')) {
+        const parts = field.split('.');
+        const last = parts.pop();
+        return [...parts, (0, pangea_helpers_1.camelToSnake)(last)].join('.');
+    }
+    return `${modelName}.${(0, pangea_helpers_1.camelToSnake)(field)}`;
+}
 function getFinalAttributes(model, attributes) {
     if (!attributes)
         return;
     return Object.entries(attributes).map(([alias, column]) => {
-        if (typeof column === 'string') {
-            const field = column.includes('.') ? column : `${model.name}.${(0, pangea_helpers_1.camelToSnake)(column)}`;
-            return [(0, sequelize_1.col)(field), alias];
-        }
-        const [op, fieldName] = column;
-        const field = fieldName.includes('.') ? fieldName : `${model.name}.${(0, pangea_helpers_1.camelToSnake)(fieldName)}`;
-        return [(0, sequelize_1.fn)(op, (0, sequelize_1.col)(field)), alias];
+        if (typeof column === 'string')
+            return [(0, sequelize_1.col)(formatField(model.name, column)), alias];
+        const [op, field] = column;
+        return [(0, sequelize_1.fn)(op, (0, sequelize_1.col)(formatField(model.name, field))), alias];
     });
 }
 function convertWhereKeys(obj) {
@@ -219,7 +234,7 @@ function convertWhereKeys(obj) {
                 const parts = inner.split('.');
                 if (parts.length >= 2) {
                     const last = parts.pop();
-                    newKey = `$${[...parts.map((part) => (0, pangea_helpers_1.camelToSnake)(part)), (0, pangea_helpers_1.camelToSnake)(last)].join('.')}$`;
+                    newKey = `$${[...parts, (0, pangea_helpers_1.camelToSnake)(last)].join('.')}$`;
                 }
             }
             newObj[newKey] = convertWhereKeys(value);
@@ -246,7 +261,7 @@ function getInclude(model, config = {}, relDepth = new Map()) {
         const relModel = rel.getModelFn();
         includeOptions.push({
             model: relModel,
-            as: rel.alias,
+            as: relName,
             attributes: !config.attributes ? undefined : [],
             required: rel.required,
             paranoid: rel.paranoid,

package/dist/database/decorators/relations.js

@@ -25,8 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasMany = exports.HasOne = exports.BelongsTo = void 0;
 const seq = __importStar(require("sequelize-typescript"));
-// helpers
-const pangea_helpers_1 = require("pangea-helpers");
 exports.BelongsTo = getRelation(seq.BelongsTo);
 exports.HasOne = getRelation(seq.HasOne);
 exports.HasMany = getRelation(seq.HasMany);
@@ -35,11 +33,10 @@ function getRelation(relationFn) {
     return function (getModelFn, options = {}) {
         return function (target, propertyName) {
             const { foreignKey, ...relOptions } = options;
-            const alias = (0, pangea_helpers_1.camelToSnake)(propertyName);
-            relationFn(getModelFn, { as: alias, ...(foreignKey && { foreignKey }) })(target, propertyName);
+            relationFn(getModelFn, { as: propertyName, ...(foreignKey && { foreignKey }) })(target, propertyName);
             const model = target.constructor;
             const { eager = relationFn !== seq.HasMany, required = relationFn === seq.BelongsTo ? !model.Columns[`${propertyName}Id`].allowNull : false, paranoid = relationFn !== seq.BelongsTo, joinDepth = 1, ...restOptions } = relOptions;
-            model.AddRelation(propertyName, { alias, getModelFn, eager, required, paranoid, joinDepth, ...restOptions });
+            model.AddRelation(propertyName, { getModelFn, eager, required, paranoid, joinDepth, ...restOptions });
         };
     };
 }

package/dist/database/models/base-model.class.d.ts

@@ -6,7 +6,6 @@ type Column = {
 };
 type Columns = Record<string, Column>;
 type Relation = {
-    alias: string;
     getModelFn: GetModelFn;
     eager: boolean;
     required: boolean;

package/package.json

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