@solidstarters/solid-core 1.2.0

package/src/services/short-url/tiny-url.service.ts

@@ -0,0 +1,60 @@
+import { HttpService } from "@nestjs/axios";
+import { Inject, Injectable, Logger } from "@nestjs/common";
+import { ConfigType } from "@nestjs/config";
+import commonConfig from "src/config/common.config";
+import { CreateShortUrlDto } from "src/dtos/create-short-url.dto";
+
+interface TinyUrlRequest {
+    url: string;
+    domain: string;
+    description: string;
+    tags: string;
+}
+
+interface TinyUrlResponse {
+    data: TinyUrlResponseData;
+    code: number;
+    errors: string[];
+}
+
+interface TinyUrlResponseData {
+    domain: string;
+    alias: string;
+    deleted: boolean;
+    archived: boolean;
+    analytics: {
+        enabled: boolean;
+        public: boolean;
+    };
+    tags: string[];
+    created_at: string;
+    expires_at: string;
+    tiny_url: string;
+    url: string;
+}
+
+@Injectable()
+export class TinyUrlService {
+    constructor(
+        @Inject(commonConfig.KEY)
+        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        private readonly httpService: HttpService,
+    ) { }
+    protected readonly logger = new Logger(TinyUrlService.name);
+    async shortenUrl(shortUrlDto: CreateShortUrlDto): Promise<string> {
+        if (!this.commonConfiguration.shortUrl.enabled) {
+            return shortUrlDto.url;
+        }
+        const shortUrlApiUrl = `${this.commonConfiguration.shortUrl.apiUrl}/create?api_token=${this.commonConfiguration.shortUrl.apiKey}`;
+        const body = this.createTinyUrlRequest(shortUrlDto)
+        const response = await this.httpService.axiosRef.post(shortUrlApiUrl, body);
+        const tinyUrlResponse = response.data as TinyUrlResponse;
+        const tinyUrl = tinyUrlResponse.data.tiny_url;
+        this.logger.debug(`Shortening URL ${shortUrlDto.url} to ${tinyUrl}`);
+        return tinyUrl;
+    }
+
+    private createTinyUrlRequest(shortUrlDto: CreateShortUrlDto): TinyUrlRequest {
+        return { url: shortUrlDto.url, domain: shortUrlDto.domain, description: shortUrlDto.description, tags: shortUrlDto.tags.join(',') };
+    }
+}

package/src/services/sms/Msg91BaseSMSService.ts

@@ -0,0 +1,79 @@
+import { Logger } from "@nestjs/common";
+import { ConfigType } from "@nestjs/config";
+import Handlebars from "handlebars";
+import commonConfig from "src/config/common.config";
+import { SmsQueuePublisher } from "src/jobs/sms-publisher.service";
+import { QueueMessage } from "src/interfaces/mq";
+import { SmsTemplateService } from "../sms-template.service";
+import { RabbitMqPublisher } from "src/services/rabbitmq-publisher.service";
+import { ISMS } from "../../interfaces";
+
+export abstract class Msg91BaseSMSService implements ISMS {
+    protected readonly logger = new Logger(Msg91BaseSMSService.name);
+    constructor(
+        protected readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        protected readonly smsPublisher: RabbitMqPublisher<any>,
+        protected readonly smsTemplateService: SmsTemplateService,
+    ) { }
+
+    sendSMS(_to: string, _body: string, _shouldQueueSms: boolean): Promise<void> {
+        throw new Error(`Msg91 does not support sending plain text messages, you need to register a template and use the templateId to send the SMS.`);
+    }
+
+    async sendSMSUsingTemplate(to: string, templateName: string, templateParams: any, shouldQueueSms = false): Promise<void> {
+        // Load template and evaluate it. 
+        const emailTemplate = await this.smsTemplateService.findOneByName(templateName);
+        if (!emailTemplate) {
+            throw new Error(`Invalid template name ${templateName}`);
+        }
+
+        // Evaluate the body template.
+        let body = null;
+        let templateId = null;
+
+        // The below code is only for reference, msh91 maintains the SMS templates in their database, and we need to only specify the templateId. 
+        // The below was designed assuming that there are certain sms gateways who do not work this way.
+        if (emailTemplate.body) {
+            const bodyTemplate = Handlebars.compile(emailTemplate.body);
+            body = bodyTemplate(templateParams);
+        }
+        if (emailTemplate.smsProviderTemplateId) {
+            templateId = emailTemplate.smsProviderTemplateId;
+        }
+        if (!body && !templateId) {
+            throw new Error(`Invalid template, neither body nor templateId specified on template with name ${templateName}`);
+        }
+
+        const message = {
+            payload: {
+                ...templateParams,
+                to: to,
+                templateId: templateId,
+            },
+            // parentEntity: 'Address', //FIXME Need to dynamically set this
+            // parentEntityId: 23, //FIXME Need to dynamically set this
+        };
+
+        // Send using queue if the developer has explicitly invoked with true.
+        if (shouldQueueSms === true) {
+            await this.sendSMSAsynchronously(message);
+        }
+        // If developer has not, however system config mandates that we send using queue, still we send.
+        else if (shouldQueueSms === false && this.commonConfiguration.shouldQueueSms === true) {
+            await this.sendSMSAsynchronously(message);
+        }
+        // Else we send synch
+        else {
+            await this.sendSMSSynchronously(message);
+        }
+    }
+
+    async sendSMSAsynchronously(message) {
+        const { to } = message.payload;
+        // this.notificationPublisherService.publish(message);
+        this.smsPublisher.publish(message);
+        this.logger.debug(`Queueing SMS to ${to} with message ${JSON.stringify(message)}`);
+    }
+
+    abstract sendSMSSynchronously(message: QueueMessage<any>): Promise<void>
+}

package/src/services/sms/Msg91OTPService.ts

@@ -0,0 +1,48 @@
+import { HttpService } from "@nestjs/axios";
+import { Inject, Injectable } from "@nestjs/common";
+import { ConfigType } from "@nestjs/config";
+import commonConfig from "src/config/common.config";
+import { SmsQueuePublisher } from "src/jobs/sms-publisher.service";
+import { QueueMessage } from "src/interfaces/mq";
+import { SmsTemplateService } from "../sms-template.service";
+import { Msg91BaseSMSService } from "./Msg91BaseSMSService";
+import { OTPQueuePublisher } from "src/jobs/otp-publisher.service";
+import { ISMS } from "../../interfaces";
+
+interface OtpParams {
+    otp: string,
+    template_id: string,
+    mobile: string,
+    authkey: string
+}
+
+@Injectable()
+export class Msg91OTPService extends Msg91BaseSMSService implements ISMS {
+    constructor(
+        @Inject(commonConfig.KEY)
+        commonConfiguration: ConfigType<typeof commonConfig>,
+        smsPublisher: OTPQueuePublisher,
+        smsTemplateService: SmsTemplateService,
+        private readonly httpService: HttpService,
+    ) {
+        super( commonConfiguration, smsPublisher, smsTemplateService )     
+     }
+
+    async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
+        const { to, templateId, otp } = message.payload;
+        const params = {otp, template_id: templateId, mobile: to, authkey: this.commonConfiguration.msg91Sms.apiKey}
+        const otpUrl = `${this.commonConfiguration.msg91Sms.url}/otp?${this.paramsToQueryString(params)}`;
+        await this.httpService.axiosRef.post(otpUrl, {});
+        this.logger.debug(`Sending OTP to ${to} with url ${otpUrl}`);
+    }
+
+    private paramsToQueryString(params: OtpParams): string {
+        const qsArray: string[] = []
+        const paramKeys = Object.keys(params)
+        for (const key of paramKeys) {
+            qsArray.push(`${key}=${encodeURIComponent(params[key])}`)
+        }
+        const qs =  qsArray.join("&");
+        return qs;
+    }
+}

package/src/services/sms/Msg91SMSService.ts

@@ -0,0 +1,30 @@
+import { HttpService } from "@nestjs/axios";
+import { Inject, Injectable } from "@nestjs/common";
+import { ConfigType } from "@nestjs/config";
+import commonConfig from "src/config/common.config";
+import { SmsQueuePublisher } from "src/jobs/sms-publisher.service";
+import { QueueMessage } from "src/interfaces/mq";
+import { SmsTemplateService } from "../sms-template.service";
+import { Msg91BaseSMSService } from "./Msg91BaseSMSService";
+import { ISMS } from "../../interfaces";
+
+@Injectable()
+export class Msg91SMSService extends Msg91BaseSMSService implements ISMS {
+    constructor(
+        @Inject(commonConfig.KEY)
+        commonConfiguration: ConfigType<typeof commonConfig>,
+        smsPublisher: SmsQueuePublisher,
+        smsTemplateService: SmsTemplateService,
+        private readonly httpService: HttpService,
+    ) {
+        super( commonConfiguration, smsPublisher, smsTemplateService )     
+     }
+
+    async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
+        const { to, templateId, ...templateParams } = message.payload;
+        const body = { template_id: templateId, short_url: "0", recipients: [{ mobiles: to, ...templateParams }] };
+        const headers = { "authkey": this.commonConfiguration.msg91Sms.apiKey };
+        await this.httpService.axiosRef.post(`${this.commonConfiguration.msg91Sms.url}/flow`, body, { headers });
+        this.logger.debug(`Sending SMS to ${to} with body ${JSON.stringify(body)} and headers ${JSON.stringify(headers)}`);
+    }
+}

package/src/services/sms-template.service.ts

@@ -0,0 +1,77 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
+import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { SmsTemplate } from '../entities/sms-template.entity';
+import { CreateSmsTemplateDto } from '../dtos/create-sms-template.dto';
+import { UpdateSmsTemplateDto } from '../dtos/update-sms-template.dto';
+
+@Injectable()
+export class SmsTemplateService {
+    constructor(
+        @InjectRepository(SmsTemplate)
+        private readonly smsTemplateRepo: Repository<SmsTemplate>,
+        @InjectEntityManager()
+        private readonly entityManager: EntityManager,
+    ) { }
+
+    create(createSmsTemplateDto: CreateSmsTemplateDto) {
+        const entity = this.smsTemplateRepo.create(createSmsTemplateDto);
+        return this.smsTemplateRepo.save(entity);
+    }
+
+    async findOneByName(name: string) {
+        const entity = await this.smsTemplateRepo.findOne({
+            where: {
+                name: name,
+            },
+        });
+        return entity;
+    }
+
+    async findAll(paginationQuery: PaginationQueryDto) {
+        const { limit, offset } = paginationQuery;
+
+        return await this.smsTemplateRepo.find({
+            skip: offset,
+            take: limit,
+        });
+    }
+
+    async findOne(id: number) {
+        const entity = await this.smsTemplateRepo.findOne({
+            where: {
+                id: id,
+            },
+        });
+        if (!entity) {
+            throw new NotFoundException(`Sms template #${id} not found`);
+        }
+        return entity;
+    }
+
+    async update(id: number, updateSmsTemplateDto: UpdateSmsTemplateDto) {
+        const entity = await this.smsTemplateRepo.preload({
+            id,
+            ...updateSmsTemplateDto,
+        });
+        if (!entity) {
+            throw new NotFoundException(`Sms template #${id} not found`);
+        }
+        return this.smsTemplateRepo.save(entity);
+    }
+
+    async removeByName(name: string) {
+        const entity = await this.findOneByName(name);
+        if (entity) {
+            return await this.smsTemplateRepo.remove(entity);
+        }
+    }
+
+    async remove(id: number) {
+        const entity = await this.findOne(id);
+        return this.smsTemplateRepo.remove(entity);
+    }
+
+}

package/src/services/solid-introspect.service.ts

@@ -0,0 +1,148 @@
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { IS_COMPUTED_FIELD_PROVIDER } from 'src/decorators/computed-field-provider.decorator';
+import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorator';
+import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+
+@Injectable()
+export class SolidIntrospectService implements OnApplicationBootstrap {
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    private readonly reflector: Reflector,
+    private readonly metadataScanner: MetadataScanner,
+    private readonly solidRegistry: SolidRegistry,
+  ) { }
+
+  private readonly logger = new Logger(SolidIntrospectService.name);
+  onApplicationBootstrap() {  
+    this.logger.log('Introspecting the application for Solid metadata');
+    
+    // Register all seeders
+    const seeders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isSeeder(provider));
+    seeders.forEach((seeder) => {
+      this.solidRegistry.registerSeeder(seeder);
+    });
+
+    // TODO: Scan the filesystem and populate the solid metadata
+
+    // Register all ISelectionProvider implementations
+    const selectionProviders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isSelectionProvider(provider));
+
+    selectionProviders.forEach((selectionProvider) => {
+      // @ts-ignore
+      this.solidRegistry.registerSelectionProvider(selectionProvider);
+    });
+
+
+    // Register all IComputedProvider implementations
+    const computedFieldProviders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isComputedFieldProvider(provider));
+
+    computedFieldProviders.forEach((computedFieldProvider) => {
+      // @ts-ignore
+      this.solidRegistry.registerComputedFieldProvider(computedFieldProvider);
+    });
+
+    // Register all ISolidDatabaseModules implementations
+    const solidDatabaseModules = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isSolidDatabaseModule(provider));
+
+      solidDatabaseModules.forEach((solidDatabaseModule) => {
+      // @ts-ignore
+      this.solidRegistry.registerSolidDatabaseModule(solidDatabaseModule);
+    });
+
+    // keep track of all the controllers & respective methods. 
+    const allControllers = this.discoveryService
+      .getControllers()
+      .map((controller) => {
+        const { instance } = controller;
+        return {
+          name: controller.name,
+          methods: this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance))
+        };
+      });
+
+    this.solidRegistry.registerControllers(new Set(allControllers));
+
+    // Register all modules
+    const allModules = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isModule(provider));
+    this.solidRegistry.registerModules(allModules);
+  }
+
+  // This method identifies a provider as a seeder if it has a seed method i.e duck typing
+  private isSeeder(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const seedMethod = this.metadataScanner
+      .getAllMethodNames(Object.getPrototypeOf(instance))
+      .find((methodName) => methodName === 'seed');
+    if (!seedMethod) return false;
+    return true;
+  }
+
+  private isSelectionProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isSelectionProvider = this.reflector.get<boolean>(
+      IS_SELECTION_PROVIDER,
+      instance.constructor,
+    );
+
+    return !!isSelectionProvider;
+  }
+
+  private isComputedFieldProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isComputedFieldProvider = this.reflector.get<boolean>(
+      IS_COMPUTED_FIELD_PROVIDER,
+      instance.constructor,
+    );
+
+    return !!isComputedFieldProvider;
+  }
+
+  private isSolidDatabaseModule(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isSolidDatabaseModule = this.reflector.get<boolean>(
+      IS_SOLID_DATABASE_MODULE,
+      instance.constructor,
+    );
+
+    return !!isSolidDatabaseModule;
+  }
+
+  private isModule(provider: InstanceWrapper) {
+    // Check if the provider is a module
+    const metatype = provider.metatype;
+    return metatype && Reflect.getMetadata('imports', metatype); 
+  }
+  // This method uses the @SolidSeeder decorator to identify if a provider is a seeder
+  // private isSeeder(provider: InstanceWrapper) {
+  //   const { instance } = provider;
+  //   if (!instance) return false;
+
+  //   const seederMetadata = this.reflector.get(
+  //     'SOLID_SERVICE',
+  //     instance.constructor,
+  //   );
+  //   if (!seederMetadata || !seederMetadata.seeder) return false;
+  //   return true;
+  // }
+}

package/src/services/user.service.ts

@@ -0,0 +1,221 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { MediaStorageProviderMetadataService } from 'src/services/media-storage-provider-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { MediaService } from "src/services/media.service";
+import { FileService } from "src/services/file.service";
+import { CrudHelperService } from "src/services/crud-helper.service";
+
+
+import { User } from '../entities/user.entity';
+import { OauthUserDto } from '../dtos/oauth-user-dto';
+import { RoleMetadata } from '../entities/role-metadata.entity';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+
+@Injectable()
+export class UserService extends CRUDService<User> {
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly mediaStorageProviderService: MediaStorageProviderMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly mediaService: MediaService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(User, 'default')
+    readonly repo: Repository<User>,
+    @InjectRepository(RoleMetadata)
+    private readonly roleRepository: Repository<RoleMetadata>,
+  ) {
+    super(modelMetadataService, moduleMetadataService, mediaStorageProviderService, configService, fileService, mediaService, discoveryService, crudHelperService, entityManager, repo, 'user', 'solid-core');
+  }
+
+
+  async findOneByEmail(email: string): Promise<User> {
+    return await this.repo.findOne({
+      where: {
+        email: email
+      },
+      relations: {}
+    });
+    // if (!entity) {
+    //     throw new NotFoundException(`user with email #${email} not found`);
+    // }
+    // return entity;
+  }
+
+  async findOneByAccessCode(accessCode: string): Promise<User> {
+    return await this.repo.findOne({
+      where: {
+        accessCode: accessCode
+      },
+      relations: {}
+    });
+  }
+
+  async findOneByUsername(username: string): Promise<User> {
+    return await this.repo.findOne({
+      where: {
+        username: username
+      },
+      relations: {}
+    });
+    // if (!entity) {
+    //     throw new NotFoundException(`user with username ${username} not found`);
+    // }
+    // return entity;
+  }
+
+  async addRoleToUser(username: string, roleName: string): Promise<User> {
+    // Find the role, find the user and populate the many 2 many table.
+    const user = await this.repo.findOne({
+      where: { username: username },
+      relations: {
+        roles: true
+      }
+    });
+    if (!user) {
+      throw new Error(`User with username '${username}' not found.`);
+    }
+    const role = await this.roleRepository.findOne({ where: { name: roleName } });
+    if (!role) {
+      throw new Error(`Role '${roleName}' not found.`);
+    }
+
+    if (user.roles && user.roles.length > 0) {
+      user.roles.push(role);
+    }
+    else {
+      user.roles = [role];
+    }
+
+    return await this.repo.save(user);
+  }
+
+  async addRolesToUser(username: string, roleNames: string[]): Promise<User> {
+    const user = await this.repo.findOne({
+      where: { username: username },
+      relations: { roles: true }
+    });
+
+    if (!user) {
+      throw new Error(`User with username '${username}' not found.`);
+    }
+
+    const roles = await this.roleRepository.find({
+      where: roleNames.map(roleName => ({ name: roleName }))
+    });
+
+    if (roles.length !== roleNames.length) {
+      const foundRoleNames = roles.map(role => role.name);
+      const missingRoles = roleNames.filter(roleName => !foundRoleNames.includes(roleName));
+      throw new Error(`The following roles were not found: ${missingRoles.join(', ')}`);
+    }
+
+    const currentRoles = user.roles.map(role => role.name);
+
+    const rolesToAdd = roles.filter(role => !currentRoles.includes(role.name));
+
+    const rolesToRemove = user.roles.filter(role => !roleNames.includes(role.name));
+
+    if (rolesToAdd.length > 0) {
+      user.roles.push(...rolesToAdd);
+    }
+
+    if (rolesToRemove.length > 0) {
+      user.roles = user.roles.filter(role => !rolesToRemove.includes(role));
+    }
+
+    return await this.repo.save(user);
+  }
+
+
+  async removeRoleFromUser(username: string, roleName: string): Promise<User> {
+
+    // load the role with the respective permissions.
+    const user = await this.repo.findOne({
+      where: {
+        username: username
+      },
+      relations: {
+        roles: true
+      }
+    });
+
+    if (!user) {
+      throw new Error(`User with username '${username}' not found.`);
+    }
+
+    // modify the permissions array.
+    user.roles = user.roles.filter(role => role.name !== roleName);
+
+    return await this.repo.save(user);
+  }
+
+  // PROVIDER SPECIFIC CODE
+  async resolveUserOnOauthGoogle(oauthUserDto: OauthUserDto): Promise<User> {
+    const user = await this.repo.findOne({
+      where: {
+        email: oauthUserDto.email,
+      },
+      relations: {
+        roles: true
+      }
+    });
+
+    // if we are unable to find a user then we need to create one. 
+    if (!user) {
+      const user = new User();
+      user.username = oauthUserDto.email;
+      user.email = oauthUserDto.email;
+      user.lastLoginProvider = oauthUserDto.provider;
+      user.accessCode = oauthUserDto.accessCode;
+      user.googleAccessToken = oauthUserDto.accessToken;
+      user.googleId = oauthUserDto.providerId;
+      user.googleProfilePicture = oauthUserDto.picture;
+
+      return await this.repo.save(user);
+    }
+    // else we update the user and store the generated code & access token. 
+    else {
+      const entity = await this.repo.preload({
+        id: user.id,
+        lastLoginProvider: oauthUserDto.provider,
+        accessCode: oauthUserDto.accessCode,
+        googleAccessToken: oauthUserDto.accessToken,
+        googleId: oauthUserDto.providerId,
+        googleProfilePicture: oauthUserDto.picture,
+      });
+
+      await this.repo.save(entity);
+    }
+
+    return user;
+  }
+
+  async findUsersByRole(roleName: string, relations: any = {}): Promise<User[]> {
+    return await this.repo.find({
+      where: {
+        roles: {
+          name: roleName
+        }
+      },
+      relations: relations
+    });
+  }
+
+  async checkIfPermissionExists(query: any, activeUser: ActiveUserData) {
+
+    const matchingPermssions = activeUser.permissions.filter((p) => query.permissionNames.includes(p));
+    return matchingPermssions
+  }
+}