pangea-server 1.0.57 → 1.0.59

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

@@ -4,30 +4,23 @@ type AttributeOp = 'COUNT' | 'SUM';
 type AttributeColumn = AttributeField | [AttributeOp, AttributeField];
 type AttributeAlias = string;
 type Attributes = Record<AttributeAlias, AttributeColumn>;
-type IncludeItem = {
-    relation?: string;
-    active?: boolean;
-    include?: IncludeItem[];
-};
 type Filters<BM extends BaseModel> = ModelId | Where<BM> | undefined;
 type Group = string[];
 type Order = Record<string, 'asc' | 'desc'>;
 type FindOneOptions = {
     scopes?: string[];
     attributes?: Attributes;
-    include?: IncludeItem[];
     order?: Order;
     paranoid?: boolean;
 };
 type FindManyOptions<BM extends BaseModel> = {
     attributes?: Attributes;
-    include?: IncludeItem[];
     where?: Where<BM>;
     searchFields?: string[];
     search?: string | null;
     group?: Group;
     order?: Order;
-    paranoid?: 'active' | 'all' | 'deleted';
+    paranoid?: boolean;
 };
 type FindManyPagedOptions<BM extends BaseModel> = FindManyOptions<BM> & {
     page?: number | null;

package/dist/database/db.class.js

@@ -13,8 +13,8 @@ class Db {
     }
     // find methods
     findOneOrNull(model, filters, options = {}) {
-        const { scopes = [], attributes, include = [], order, paranoid = true } = options;
-        const scopedModel = scopes.length ? model.scope(...scopes) : model;
+        const { scopes, attributes, order, paranoid = true } = options;
+        const scopedModel = scopes?.length ? model.scope(...scopes) : model;
         const baseOptions = {
             attributes: getFinalAttributes(attributes),
             paranoid,
@@ -22,11 +22,11 @@ class Db {
             transaction: this.__tx,
         };
         if (typeof filters === 'number') {
-            return scopedModel.findByPk(filters, { ...baseOptions, ...getIncludeAndWhere(model, include) });
+            return scopedModel.findByPk(filters, { ...baseOptions, ...getInclude(model) });
         }
         return scopedModel.findOne({
             ...baseOptions,
-            ...getIncludeAndWhere(model, include, { withoutAttributes: !!attributes }, filters),
+            ...getInclude(model, { attributes, where: filters }),
             order: getFinalOrder(order),
         });
     }
@@ -67,7 +67,7 @@ class Db {
         return { instances, totalCount: instances.length };
     }
     __getFindManyBaseOptions(model, options = {}) {
-        const { attributes, include = [], where, searchFields, search, group, order, paranoid = 'active' } = options;
+        const { attributes, where, searchFields, search, group, order, paranoid = true } = options;
         let searchWhere;
         if (searchFields?.length && search) {
             const searchWords = search.split(/\s+/).filter(Boolean);
@@ -80,13 +80,12 @@ class Db {
                 })),
             };
         }
-        const deletedAtWhere = paranoid === 'deleted' ? { deletedAt: { [_1.Ops.not]: null } } : {};
         return {
             attributes: getFinalAttributes(attributes),
-            ...getIncludeAndWhere(model, include, { withoutAttributes: !!attributes }, { ...where, ...searchWhere, ...deletedAtWhere }),
+            ...getInclude(model, { attributes, where: { ...where, ...searchWhere } }),
             ...(group && { group: group.map(pangea_helpers_1.camelToSnake) }),
-            order: [...getFinalOrder(order), ...(!group ? [['createdAt', 'DESC']] : [])],
-            paranoid: paranoid === 'active',
+            order: getFinalOrder(order),
+            paranoid,
             subQuery: false,
             transaction: this.__tx,
         };
@@ -223,17 +222,16 @@ function convertWhereKeys(obj) {
     }
     return obj;
 }
-function getIncludeAndWhere(model, includeItems, config = {}, where, relDepth = new Map()) {
+function getInclude(model, config = {}, relDepth = new Map()) {
     const includeOptions = [];
-    const cleanWhere = { ...where };
+    const cleanWhere = { ...config.where };
     for (const [relName, rel] of Object.entries(model.Relations)) {
         const relKey = `${model.name}.${relName}`;
         const currentDepth = relDepth.get(relKey) || 0;
         const maxDepth = rel.joinDepth;
         if (currentDepth >= maxDepth)
             continue;
-        const { active = true, include: nestedIncludeItems = [] } = includeItems.find((i) => i.relation === relName) || {};
-        if (!rel.eager || !active)
+        if (!rel.eager)
             continue;
         const relWhere = cleanWhere[relName];
         delete cleanWhere[relName];
@@ -242,11 +240,11 @@ function getIncludeAndWhere(model, includeItems, config = {}, where, relDepth =
         const relModel = rel.getModelFn();
         includeOptions.push({
             model: relModel,
-            as: rel.as,
-            attributes: !config.withoutAttributes ? undefined : [],
+            as: rel.alias,
+            attributes: !config.attributes ? undefined : [],
             required: rel.required,
             paranoid: rel.paranoid,
-            ...getIncludeAndWhere(relModel, nestedIncludeItems, config, relWhere, newRelDepth),
+            ...getInclude(relModel, { ...config, where: relWhere }, newRelDepth),
         });
     }
     return {
@@ -254,12 +252,15 @@ function getIncludeAndWhere(model, includeItems, config = {}, where, relDepth =
         ...(Reflect.ownKeys(cleanWhere).length && { where: convertWhereKeys(cleanWhere) }),
     };
 }
-function getFinalOrder(order) {
-    return Object.entries(order || {}).map(([key, value]) => {
+function getFinalOrder(order, config = {}) {
+    if (!order)
+        return;
+    const finalOrder = Object.entries(order).map(([key, value]) => {
         const parts = key.split('.');
         const direction = value.toUpperCase();
         return [...parts, direction];
     });
+    return [...finalOrder, ...(!config.attributes ? [['createdAt', 'DESC']] : [])];
 }
 async function handleDbError(operation) {
     try {

package/dist/database/decorators/relations.js

@@ -35,11 +35,11 @@ function getRelation(relationFn) {
     return function (getModelFn, options = {}) {
         return function (target, propertyName) {
             const { foreignKey, ...relOptions } = options;
-            const as = (0, pangea_helpers_1.camelToSnake)(propertyName);
-            relationFn(getModelFn, { as, ...(foreignKey && { foreignKey }) })(target, propertyName);
+            const alias = (0, pangea_helpers_1.camelToSnake)(propertyName);
+            relationFn(getModelFn, { as: alias, ...(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, { as, getModelFn, eager, required, paranoid, joinDepth, ...restOptions });
+            model.AddRelation(propertyName, { alias, getModelFn, eager, required, paranoid, joinDepth, ...restOptions });
         };
     };
 }

package/dist/database/decorators/table.js

@@ -35,17 +35,13 @@ function Table(tableName, options = {}) {
         const allIndexes = [...tableIndexes, ...columnIndexes];
         seq.Table({
             tableName,
-            // modelName: camelToSnake(target.name), // 'as' in SQL query
             charset: 'utf8mb4',
             collate: 'utf8mb4_general_ci',
             underscored: true,
             timestamps: true,
             paranoid: true,
             indexes: allIndexes.map(({ field, fields, ...restIndex }) => {
-                return {
-                    ...restIndex,
-                    fields: fields ? fields.map(pangea_helpers_1.camelToSnake) : field ? [(0, pangea_helpers_1.camelToSnake)(field)] : [],
-                };
+                return { ...restIndex, fields: fields ? fields.map(pangea_helpers_1.camelToSnake) : field ? [(0, pangea_helpers_1.camelToSnake)(field)] : [] };
             }),
         })(target);
         const excludedAttributes = target.ExcludedAttributes;

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

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

package/dist/database/seed.helpers.js

@@ -28,17 +28,13 @@ async function seedTables(models, seeds) {
     (0, helpers_1.printInfo)('database', 'seeding tables...');
     const modelsToSeed = Object.values(models)
         .filter(() => (0, helpers_1.getEnvBool)('DB_INCLUDE_TESTING_SEEDS'))
-        .map((model) => {
-        console.log(model.name);
-        return model.name;
-    });
+        .map((model) => model.name);
     const modelsWithData = modelsToSeed.filter((modelName) => seeds[modelName]?.length);
     const tx = await (0, db_client_1.getDbClient)().transaction();
     const db = new db_class_1.Db(tx);
     try {
         await db.disableForeignKeyChecks();
         await Promise.all(modelsWithData.map((modelName) => db.insertMany(models[modelName], seeds[modelName])));
-        console.log('hola');
         await db.enableForeignKeyChecks();
         await tx.commit();
     }

package/package.json

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