@appxdigital/appx-core 0.1.68

package/dist/prisma/prisma.service.js

@@ -0,0 +1,512 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaService = void 0;
+const common_1 = require("@nestjs/common");
+const client_1 = require("@prisma/client");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const nestjs_request_context_1 = require("nestjs-request-context");
+let PrismaService = class PrismaService {
+    constructor(prismaClient, permissionsConfig) {
+        this.permissionsConfig = permissionsConfig;
+        this.fieldConfigs = {};
+        this.schemaPath = '';
+        this.prismaClient = prismaClient;
+        this.parseSchema();
+        this.proxyModels();
+    }
+    $transaction(fn) {
+        return this.prismaClient.$transaction(fn);
+    }
+    proxyModels() {
+        // Proxy client to intercept model calls
+        this.prismaClient = new Proxy(this.prismaClient, {
+            get: (target, propKey) => {
+                const modelDelegate = target[propKey];
+                if (typeof modelDelegate === 'object' && modelDelegate !== null && !['$connect', '$disconnect', '$use', '$on'].includes(propKey.toString()) && !propKey.toString().startsWith?.('_') && !propKey.toString().startsWith?.('$')) {
+                    // Proxy model methods to apply field omission and where conditions
+                    return new Proxy(modelDelegate, {
+                        get: (model, methodKey) => {
+                            const user = nestjs_request_context_1.RequestContext.currentContext?.req.user || {};
+                            const userRole = user?.role || 'GUEST';
+                            if (typeof model[methodKey] === 'function' && !methodKey.toString().startsWith('_') && !methodKey.toString().startsWith('$')) {
+                                const contextModel = nestjs_request_context_1.RequestContext.currentContext?.req.prisma?.[propKey] || model;
+                                return async (params, options) => {
+                                    // delete, deleteMany, update and updateMany methods should not apply field omission because they are not selecting fields
+                                    if (!options?.BYPASS_OMISSION && !['delete', 'deleteMany', 'update', 'updateMany'].includes(methodKey.toString()))
+                                        params = this.applyFieldOmission(String(propKey), userRole, params);
+                                    if (!options?.BYPASS_FILTERING) {
+                                        params = this.applyWhereConditions(String(propKey), userRole, params, user, methodKey);
+                                        // findUnique should be findFirst for where conditions to work properly
+                                        if (methodKey === 'findUnique')
+                                            methodKey = 'findFirst';
+                                        // delete should become deleteMany for where conditions to work properly
+                                        if (methodKey === 'delete')
+                                            methodKey = 'deleteMany';
+                                        // update should become updateMany for where conditions to work properly
+                                        if (methodKey === 'update')
+                                            methodKey = 'updateMany';
+                                    }
+                                    if (methodKey === 'count' && !!params.select) {
+                                        delete params.select;
+                                    }
+                                    return contextModel[methodKey](params);
+                                };
+                            }
+                            return model[methodKey];
+                        },
+                    });
+                }
+                return modelDelegate;
+            },
+        });
+    }
+    /**
+     * Retrieves the model delegate from the Prisma client.
+     * Used in the graphql generic resolver
+     * @param model
+     */
+    getModelDelegate(model) {
+        const modelName = model.toLowerCase();
+        const client = this.prismaClient;
+        if (modelName in client) {
+            return client[modelName];
+        }
+        throw new Error(`Model ${model.toString()} not found in PrismaClient.`);
+    }
+    get model() {
+        return new Proxy(nestjs_request_context_1.RequestContext.currentContext?.req.prisma || this.prismaClient, {
+            get: (target, prop) => {
+                if (prop in target) {
+                    return target[prop];
+                }
+                else {
+                    throw new Error(`Model ${String(prop)} does not exist on PrismaClient`);
+                }
+            },
+        });
+    }
+    get user() {
+        return this.prismaClient.user;
+    }
+    get session() {
+        return this.prismaClient.session;
+    }
+    /**
+     * Parses the Prisma schema to extract model information and field configurations
+     * including custom annotations (e.g., @Role(CLIENT)) and enums.
+     */
+    parseSchema() {
+        this.schemaPath = path.join(process.cwd(), 'prisma/schema.prisma');
+        const schema = fs.readFileSync(this.schemaPath, 'utf-8');
+        const enums = this.extractEnumsFromSchema(schema);
+        this.fieldConfigs = this.extractModelsFromSchema(schema, enums);
+    }
+    /**
+     * Extracts enums from the Prisma schema.
+     * @param schema - The raw schema content as a string.
+     * @returns An array of enum names.
+     */
+    extractEnumsFromSchema(schema) {
+        const enumRegex = /enum\s+(\w+)\s+\{/g;
+        const enums = [];
+        let match;
+        while ((match = enumRegex.exec(schema)) !== null) {
+            enums.push(match[1]);
+        }
+        return enums;
+    }
+    /**
+     * Extracts models and custom annotations from the Prisma schema.
+     * @param schema - The raw schema content as a string.
+     * @param enums - An array of enum names for determining scalar fields.
+     * @returns A parsed object with models and their custom annotations.
+     */
+    extractModelsFromSchema(schema, enums) {
+        const models = {};
+        const modelRegex = /model\s+(\w+)\s+\{([\s\S]+?)\}/g;
+        let match;
+        while ((match = modelRegex.exec(schema)) !== null) {
+            const modelName = match[1];
+            const modelBody = match[2];
+            const { allFields, fieldConfig, fieldTypes, scalarFields, relationFields, } = this.extractFieldsFromModel(modelBody);
+            models[modelName.toLowerCase()] = {
+                fieldConfig,
+                allFields,
+                fieldTypes,
+                scalarFields,
+                relationFields,
+            };
+        }
+        return models;
+    }
+    /**
+     * Extracts fields from the model and looks for custom annotations like @Role.
+     * @param modelBody - The body of the model in the schema.
+     * @returns A parsed object with fields and their custom annotations.
+     */
+    extractFieldsFromModel(modelBody) {
+        const allFields = [];
+        const fieldConfig = {};
+        const fieldTypes = {};
+        const scalarFields = [];
+        const relationFields = [];
+        const lines = modelBody.split('\n');
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('//')) {
+                continue;
+            }
+            const [codePart, commentPart] = trimmedLine.split('///');
+            const codeTokens = codePart.trim().split(/\s+/);
+            if (codeTokens.length < 2) {
+                continue;
+            }
+            const fieldName = codeTokens[0];
+            const fieldType = codeTokens[1];
+            const attributes = codeTokens.slice(2);
+            if (commentPart && commentPart.includes('@Role(')) {
+                const roleMatch = commentPart.match(/@Role\((.*?)\)/);
+                if (roleMatch) {
+                    const roles = roleMatch[1].split(',').map(role => role.trim());
+                    fieldConfig[fieldName] = roles;
+                }
+            }
+            allFields.push(fieldName);
+            fieldTypes[fieldName] = fieldType;
+            let baseType = fieldType.replace('?', '').replace('[]', '');
+            if (this.isScalarType(baseType)) {
+                scalarFields.push(fieldName);
+            }
+            else {
+                relationFields.push(fieldName);
+            }
+        }
+        return {
+            allFields,
+            fieldConfig,
+            fieldTypes,
+            scalarFields,
+            relationFields,
+        };
+    }
+    // Helper method to identify scalar types
+    isScalarType(fieldType) {
+        const scalarTypes = ['Int', 'String', 'Boolean', 'DateTime', 'Float', 'BigInt', 'Decimal', 'Json', 'Bytes', 'Unsupported'];
+        return scalarTypes.includes(fieldType);
+    }
+    /**
+     * Applies field omission logic based on the user's role.
+     * Fields that the user does not have permission to access are removed from the query.
+     *
+     * @param modelName - The name of the Prisma model being queried.
+     * @param userRole - The current user's role (e.g., 'ADMIN', 'CLIENT').
+     * @param args - The query arguments, including `select` or `include`.
+     * @returns The modified query arguments with omitted fields.
+     */
+    applyFieldOmission(modelName, userRole, args) {
+        const omitFields = this.getFieldsToOmit(modelName, userRole);
+        if (!args) {
+            args = {};
+        }
+        if (args.select) {
+            omitFields.forEach((field) => {
+                delete args.select[field];
+            });
+        }
+        else if (args.include) {
+            args.select = this.buildSelectFields(modelName, omitFields, args.include, userRole);
+            delete args.include;
+        }
+        else {
+            args.select = this.buildSelectFields(modelName, omitFields, null, userRole);
+        }
+        return args;
+    }
+    get normalizedPermissionsConfig() {
+        const normalizedConfig = {};
+        for (const model in this.permissionsConfig) {
+            normalizedConfig[model.toLowerCase()] = this.permissionsConfig[model];
+        }
+        return normalizedConfig;
+    }
+    /**
+     * Applies `where` conditions to the query based on the user's role and the action being performed.
+     * The conditions are pulled from the `PermissionsConfig`.
+     *
+     * @param modelName - The name of the model being queried.
+     * @param userRole - The role of the user making the request.
+     * @param args - The query arguments (including `where`).
+     * @param user - The user object containing information like `id`.
+     * @param action - The action being performed (e.g., 'find', 'update').
+     * @returns The modified query arguments with the appropriate `where` conditions applied.
+     * @throws ForbiddenException if no valid `where` conditions are present after applying permissions.
+     */
+    applyWhereConditions(modelName, userRole, args, user, action) {
+        if (!args) {
+            args = {};
+        }
+        const belongsToQueue = [];
+        const permissionsConfig = this.normalizedPermissionsConfig;
+        const normalizedName = modelName.toLowerCase().trim();
+        const permissions = permissionsConfig[normalizedName]?.[userRole];
+        for (const model of Object.keys(args.select)) {
+            if (!this.fieldConfigs[model.toLowerCase()]) {
+                continue;
+            }
+            const relation = this.getRelationType(modelName, model);
+            if (relation.relation === 'belongsTo') {
+                const relatedPermissions = permissionsConfig[model.toLowerCase()]?.[userRole]?.[action];
+                belongsToQueue.push({
+                    modelName: model,
+                    relation,
+                    relatedPermissions,
+                });
+                continue;
+            }
+            if (permissionsConfig[model.toLowerCase()]) {
+                this.applyWhereConditions(model, userRole, args.select[model], user, action);
+            }
+            else {
+                throw new common_1.ForbiddenException(`No permissions found for model ${model} and role ${userRole}`);
+            }
+        }
+        if (!permissions) {
+            throw new common_1.HttpException(`No permissions found for model ${modelName} and role ${userRole}`, common_1.HttpStatus.FORBIDDEN);
+        }
+        const actionPermissions = permissions[action];
+        if (!actionPermissions || (actionPermissions === 'ALL' && !belongsToQueue?.length) || action === 'create') {
+            return args;
+        }
+        const whereClause = this.buildConditions(actionPermissions.conditions, user);
+        if (!args.where) {
+            args.where = {};
+        }
+        args.where = { AND: [args.where, whereClause] };
+        //TODO Test this in more scenarios, it may need to be more robust, it's a quick fix but I must make sure it wont be abused by adding a model with this type of relation to bypass something it shouldn't
+        if (Object.keys(args.where).length === 0 && !belongsToQueue?.length) {
+            throw new common_1.ForbiddenException(`You are not authorized to access this record`);
+        }
+        for (const entry of belongsToQueue) {
+            const { modelName: relatedModel, relatedPermissions } = entry;
+            args.where = {
+                ...args.where,
+                [relatedModel]: {
+                    AND: [
+                        args?.where?.[relatedModel] ?? {},
+                        this.buildConditions(relatedPermissions?.conditions, user)
+                    ]
+                }
+            };
+            //TODO This may no longer be of use, since we are defaulting to not returning the parent if it includes a model the user has no access to.
+            // if (relatedPermissions?.conditions) {
+            //     const relatedWhere = this.buildConditions(relatedPermissions.conditions, user);
+            //     const foreignKey = relation.identifier;
+            //     const foreignKeyValue = args.where?.[foreignKey];
+            //     const requiredValue = relatedWhere[foreignKey] || relatedWhere.id;
+            //
+            //
+            //     if (requiredValue !== undefined && foreignKeyValue !== requiredValue) {
+            // throw new common_1.ForbiddenException(
+            //     `Access denied: You are requesting ${modelName.toUpperCase()} with an associated ${relatedModel.toUpperCase()}, ` +
+            //     `but your permissions only allow access to ${relatedModel.toUpperCase()} where ${foreignKey} is ${requiredValue}. ` +
+            //     `The requested record has ${foreignKey} = ${foreignKeyValue}.`
+            // );
+            //     }
+            // }
+        }
+        return args;
+    }
+    getRelationType(parentModel, relatedField) {
+        //TODO Remove what is now unnecessary since this is no longer used to determine the foreign key and it was very strict due to relying on the assumption that said fk would be [model name]_id
+        parentModel = parentModel.toLowerCase();
+        relatedField = relatedField.toLowerCase();
+        const parentKey = Object.keys(this.fieldConfigs).find(key => key.toLowerCase() === parentModel);
+        if (!parentKey)
+            return { relation: null, identifier: null };
+        const parent = this.fieldConfigs[parentKey];
+        const relationKey = parent.relationFields.find((key) => key.toLowerCase() === relatedField);
+        if (!relationKey)
+            return { relation: null, identifier: null };
+        const fieldType = parent.fieldTypes[relationKey];
+        if (fieldType.endsWith('[]')) {
+            return { relation: 'hasMany', identifier: null };
+        }
+        const foreignKeyName = `${relatedField}_id`;
+        const foreignKey = parent.scalarFields.find((key) => key.toLowerCase() === foreignKeyName);
+        if (foreignKey) {
+            return { relation: 'belongsTo', identifier: foreignKey };
+        }
+        return { relation: null, identifier: null };
+    }
+    /**
+     * Builds dynamic conditions based on the type of clause (OR, AND, or field conditions).
+     * Each condition is processed, and placeholders (like `$USER_ID`) are replaced with actual values.
+     *
+     * @param conditions - An array of clauses that define the conditions for the query.
+     * @param user - The user object used to replace placeholders.
+     * @returns The constructed `where` clause object.
+     */
+    buildConditions(conditions, user) {
+        const whereClause = {};
+        if (!conditions) {
+            return whereClause;
+        }
+        for (let field in conditions) {
+            whereClause[field] = this.replacePlaceholders(conditions[field], user);
+        }
+        return whereClause;
+    }
+    /**
+     * Replaces placeholders (like `$USER_ID`) in the condition with actual values from the user object.
+     * Handles conditions in the form of strings, arrays, or objects.
+     *
+     * @param condition - The condition that might contain placeholders.
+     * @param user - The user object containing values like `id`.
+     * @returns The condition with placeholders replaced by actual values.
+     */
+    replacePlaceholders(condition, user) {
+        if (typeof condition === 'string') {
+            if (condition === '$USER_ID') {
+                return user.id;
+            }
+            return condition;
+        }
+        if (Array.isArray(condition)) {
+            return condition.map((item) => this.replacePlaceholders(item, user));
+        }
+        if (typeof condition === 'object') {
+            const replaced = {};
+            for (const key in condition) {
+                replaced[key] = this.replacePlaceholders(condition[key], user);
+            }
+            return replaced;
+        }
+        return condition;
+    }
+    /**
+     * Retrieves the list of fields to omit based on the user's role.
+     * It checks the field configurations stored in `fieldConfigs` and compares them against the role.
+     *
+     * @param modelName - The name of the model being queried.
+     * @param role - The role of the user making the request.
+     * @returns An array of field names to be omitted from the query.
+     */
+    getFieldsToOmit(modelName, role) {
+        const modelInfo = this.fieldConfigs[modelName.toLowerCase()] || {};
+        const fieldConfig = modelInfo.fieldConfig || {};
+        return Object.entries(fieldConfig)
+            .filter(([_, roles]) => !roles.includes(role))
+            .map(([field]) => field);
+    }
+    /**
+     * Builds the `select` object for Prisma queries, omitting fields based on the user's role.
+     * It handles both scalar fields and relation fields.
+     *
+     * @param modelName - The name of the model being queried.
+     * @param omitFields - A list of fields to omit based on the user's role.
+     * @param includeRelations - The relations to include in the query.
+     * @param userRole - The role of the user making the request.
+     * @returns A `select` object for Prisma queries.
+     */
+    buildSelectFields(modelName, omitFields, includeRelations, userRole) {
+        const modelInfo = this.fieldConfigs[modelName.toLowerCase()];
+        if (!modelInfo) {
+            return {};
+        }
+        const { scalarFields, relationFields } = modelInfo;
+        const selectFields = {};
+        for (const field of scalarFields) {
+            if (!omitFields.includes(field)) {
+                selectFields[field] = true;
+            }
+        }
+        if (includeRelations) {
+            for (const relationKey in includeRelations) {
+                if (!relationFields.includes(relationKey))
+                    continue;
+                let includedArgs = includeRelations[relationKey];
+                if (includedArgs === true) {
+                    includedArgs = {};
+                }
+                const relatedModelName = this.getRelatedModelName(modelName, relationKey);
+                const relatedModelOmitFields = this.getFieldsToOmit(relatedModelName, userRole);
+                const relatedSelectFields = this.buildSelectFields(relatedModelName, relatedModelOmitFields, includedArgs.include || null, userRole);
+                if (Object.keys(relatedSelectFields).length > 0) {
+                    selectFields[relationKey] = { select: relatedSelectFields };
+                }
+            }
+        }
+        return selectFields;
+    }
+    /**
+     * Retrieves the related model's name for a given relation field.
+     * This is used to navigate relations between models when constructing the `select` object.
+     *
+     * @param parentModelName - The name of the parent model.
+     * @param relationKey - The key of the relation field.
+     * @returns The name of the related model.
+     * @throws Error if the relation field is not found in the parent model.
+     */
+    getRelatedModelName(parentModelName, relationKey) {
+        const modelInfo = this.fieldConfigs[parentModelName.toLowerCase()];
+        if (!modelInfo) {
+            throw new Error(`Model information not found for ${parentModelName}`);
+        }
+        if (modelInfo.relationFields.includes(relationKey)) {
+            return modelInfo.fieldTypes[relationKey].toLowerCase();
+        }
+        throw new Error(`Relation key ${relationKey} not found in model ${parentModelName}`);
+    }
+};
+exports.PrismaService = PrismaService;
+exports.PrismaService = PrismaService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)('PERMISSIONS_CONFIG')),
+    __metadata("design:paramtypes", [Object, Object])
+], PrismaService);

package/dist/tasks/session-cleanup.service.d.ts

@@ -0,0 +1,7 @@
+import { PrismaService } from '../prisma/prisma.service';
+export declare class SessionCleanupService {
+    private prisma;
+    constructor(prisma: PrismaService);
+    cleanUpExpiredSessions(): Promise<void>;
+}
+//# sourceMappingURL=session-cleanup.service.d.ts.map

package/dist/tasks/session-cleanup.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-cleanup.service.d.ts","sourceRoot":"","sources":["../../src/tasks/session-cleanup.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD,qBACa,qBAAqB;IAClB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAGnC,sBAAsB;CAO/B"}

package/dist/tasks/session-cleanup.service.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionCleanupService = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const prisma_service_1 = require("../prisma/prisma.service");
+let SessionCleanupService = class SessionCleanupService {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    async cleanUpExpiredSessions() {
+        await this.prisma.session.deleteMany({
+            where: {
+                expiresAt: { lte: new Date() },
+            },
+        });
+    }
+};
+exports.SessionCleanupService = SessionCleanupService;
+__decorate([
+    (0, schedule_1.Cron)('0 * * * *'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SessionCleanupService.prototype, "cleanUpExpiredSessions", null);
+exports.SessionCleanupService = SessionCleanupService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [prisma_service_1.PrismaService])
+], SessionCleanupService);

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@appxdigital/appx-core",
+    "version": "0.1.68",
+    "description": "Appx Core is a library that provides a set of tools to help you build your application faster.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "npm:publish": "rimraf dist && npm run build && npm publish --access=public",
+        "db-pull": "npx prisma db pull && prisma-case-format --table-case pascal --field-case camel --enum-case pascal --file prisma/schema.prisma"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "@aws-sdk/client-s3": "^3.688.0",
+        "@aws-sdk/types": "^3.686.0",
+        "@google-cloud/storage": "^7.14.0",
+        "@paljs/plugins": "^8.1.0",
+        "@paralleldrive/cuid2": "^2.2.2",
+        "@types/bcrypt": "^5.0.2",
+        "@types/express": "^5.0.0",
+        "@types/express-session": "^1.18.0",
+        "argon2": "^0.41.1",
+        "class-transformer": "^0.5.1",
+        "class-validator": "^0.14.1",
+        "express": "^4.21.1",
+        "express-session": "^1.18.1",
+        "graphql-type-json": "^0.3.2",
+        "inquirer": "^12.0.1",
+        "multer": "^1.4.5-lts.1",
+        "passport": "^0.7.0",
+        "passport-local": "^1.0.0",
+        "prisma-case-format": "^2.2.1",
+        "prisma-nestjs-graphql": "21.1.1"
+    },
+    "devDependencies": {
+        "@prisma/client": "^6.5.0",
+        "@types/express-formidable": "^1.2.3",
+        "@types/inquirer": "^9.0.7",
+        "@types/multer": "^1.4.12",
+        "@types/passport-local": "^1.0.38",
+        "typescript": "^5.1.3"
+    },
+    "peerDependencies": {
+        "@nestjs/apollo": "^13.0.0",
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/config": "^4.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/graphql": "^13.1.0",
+        "@nestjs/passport": "^11.0.0",
+        "@nestjs/platform-express": "^11.0.0",
+        "@nestjs/schedule": "^5.0.0",
+        "@prisma/client": "^6.5.0",
+        "nestjs-request-context": "^4.0.0",
+        "reflect-metadata": "^0.2.0",
+        "rxjs": "^7.8.1"
+    },
+    "overrides": {
+        "rimraf": "^4.0.0",
+        "glob": "^9.0.0"
+    },
+    "files": [
+        "dist"
+    ]
+}