@solidxai/core 0.1.9-beta.6 → 0.1.9-beta.8

package/src/helpers/string.helper.ts

@@ -2,3 +2,6 @@ export const lowerFirst = (str: string): string => {
     if (!str) return str;
     return str.charAt(0).toLowerCase() + str.slice(1);
 }
+
+import { upperFirst, camelCase } from 'lodash';
+export const classify = (s: string): string => upperFirst(camelCase(s));

package/src/helpers/user-helper.ts

@@ -11,6 +11,10 @@ export function getUserExcludedFields(): string[] {
     "forcePasswordChange",
     "lastLoginProvider",
     "googleProfilePicture",
+    "facebookAccessToken",
+    "facebookId",
+    "microsoftAccessToken",
+    "microsoftId",
     "forgotPasswordConfirmedAt",
     "verificationTokenOnForgotPassword",
     "verificationTokenOnForgotPasswordExpiresAt",

package/src/index.ts

@@ -261,6 +261,8 @@ export * from './jobs/redis/twilio-sms-subscriber-redis.service'
 export * from './listeners/user-registration.listener'
 
 export * from './passport-strategies/google-oauth.strategy'
+export * from './passport-strategies/facebook-oauth.strategy'
+export * from './passport-strategies/microsoft-oauth.strategy'
 
 export * from './services/selection-providers/list-of-values-selection-providers.service'
 

package/src/interfaces.ts

@@ -68,12 +68,44 @@ export enum SettingLevel {
   InternalUser = "internal-user"
 }
 
+export type SettingControlType =
+  | 'shortText'
+  | 'longText'
+  | 'numeric'
+  | 'boolean'
+  | 'date'
+  | 'datetime'
+  | 'mediaSingle'
+  | 'selectionStatic'
+  | 'custom';
+
+export interface SettingOption {
+  label: string;
+  value: string | number | boolean;
+}
+
 export interface SettingDefinition<T = any> {
   moduleName: string;
   key: string;
   value: T;
   level: SettingLevel;
   encrypted?: boolean;
+  label?: string;
+  description?: string;
+  placeholder?: string;
+  group?: string;
+  sortOrder?: number;
+  controlType?: SettingControlType;
+  options?: SettingOption[];
+  settingsWidget?: string; // for custom controlType, specify the frontend widget to use
+}
+
+export interface AdminSettingDefinition<T = any> extends SettingDefinition<T> {
+  editable: boolean;
+}
+
+export interface AdminSettingsResponse<T = any> {
+  data: AdminSettingDefinition<T>[];
 }
 
 // solid-core/settings/settings-provider.interface.ts
@@ -419,4 +451,3 @@ export interface AuditQueuePayload {
     userId?: number | null;
 }
 
-

package/src/passport-strategies/facebook-oauth.strategy.ts

@@ -0,0 +1,64 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { AuthGuard, PassportStrategy } from '@nestjs/passport';
+import { Strategy } from 'passport-facebook';
+import { FacebookAuthConfiguration, isFacebookOAuthConfigured } from 'src/helpers/facebook-oauth.helper';
+import { v4 as uuid } from 'uuid';
+import { UserService } from '../services/user.service';
+
+const DUMMY_CLIENT_ID = 'DUMMY_CLIENT_ID';
+const DUMMY_CLIENT_SECRET = 'DUMMY_CLIENT_SECRET';
+const DUMMY_CALLBACK_URL = 'DUMMY_CALLBACK_URL';
+
+@Injectable()
+export class FacebookOauthGuard extends AuthGuard('facebook') { }
+
+@Injectable()
+export class FacebookOAuthStrategy extends PassportStrategy(Strategy, 'facebook') {
+  private readonly logger = new Logger(FacebookOAuthStrategy.name);
+
+  constructor(private readonly userService: UserService) {
+    // Reading configuration from environment variables (Static approach like Google)
+    const clientID = process.env.IAM_FACEBOOK_OAUTH_CLIENT_ID ?? DUMMY_CLIENT_ID;
+    const clientSecret = process.env.IAM_FACEBOOK_OAUTH_CLIENT_SECRET ?? DUMMY_CLIENT_SECRET;
+    const callbackURL = process.env.IAM_FACEBOOK_OAUTH_CALLBACK_URL ?? DUMMY_CALLBACK_URL;
+    const redirectURL = process.env.IAM_FACEBOOK_OAUTH_REDIRECT_URL;
+
+    super({
+      clientID,
+      clientSecret,
+      callbackURL,
+      scope: ['email'],
+      profileFields: ['id', 'emails', 'name', 'photos'],
+    });
+
+    const facebookOauth: FacebookAuthConfiguration = { clientID, clientSecret, callbackURL, redirectURL };
+    if (!isFacebookOAuthConfigured(facebookOauth)) {
+      this.logger.debug('Facebook OAuth strategy is not configured');
+    }
+  }
+
+  async validate(_accessToken: string, _refreshToken: string, profile: any, done: any): Promise<any> {
+    const { id, name, emails, photos } = profile;
+
+    // generate a unique access code. 
+    const loginAccessCode: string = uuid();
+
+    const user = {
+      provider: 'facebook',
+      providerId: id,
+      email: emails?.[0]?.value,
+      name: `${name.givenName} ${name.familyName}`,
+      picture: photos?.[0]?.value,
+      accessCode: loginAccessCode,
+    };
+
+    // store the access code and the access token in the database. 
+    await this.userService.resolveUserOnOauthFacebook({ 
+        ...user, 
+        accessToken: _accessToken, 
+        refreshToken: null 
+    });
+
+    done(null, user);
+  }
+}

package/src/passport-strategies/microsoft-oauth.strategy.ts

@@ -0,0 +1,70 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { AuthGuard, PassportStrategy } from '@nestjs/passport';
+import { Strategy } from 'passport-microsoft';
+import { MicrosoftAuthConfiguration, isMicrosoftOAuthConfigured } from 'src/helpers/microsoft-oauth.helper';
+import { v4 as uuid } from 'uuid';
+import { UserService } from '../services/user.service';
+
+const DUMMY_CLIENT_ID = 'DUMMY_CLIENT_ID';
+const DUMMY_CLIENT_SECRET = 'DUMMY_CLIENT_SECRET';
+const DUMMY_TENANT = 'common';
+const DUMMY_CALLBACK_URL = 'DUMMY_CALLBACK_URL';
+
+@Injectable()
+export class MicrosoftOauthGuard extends AuthGuard('microsoft') { }
+
+@Injectable()
+export class MicrosoftOAuthStrategy extends PassportStrategy(Strategy, 'microsoft') {
+  private readonly logger = new Logger(MicrosoftOAuthStrategy.name);
+
+  constructor(private readonly userService: UserService) {
+    // Reading configuration from environment variables (Static approach like Google)
+    const clientID = process.env.IAM_MICROSOFT_OAUTH_CLIENT_ID ?? DUMMY_CLIENT_ID;
+    const clientSecret = process.env.IAM_MICROSOFT_OAUTH_CLIENT_SECRET ?? DUMMY_CLIENT_SECRET;
+    const tenant = process.env.IAM_MICROSOFT_OAUTH_TENANT_ID ?? DUMMY_TENANT;
+    const callbackURL = process.env.IAM_MICROSOFT_OAUTH_CALLBACK_URL ?? DUMMY_CALLBACK_URL;
+    const redirectURL = process.env.IAM_MICROSOFT_OAUTH_REDIRECT_URL;
+
+    super({
+      clientID,
+      clientSecret,
+      callbackURL,
+      tenant,
+      scope: ['user.read'],
+      addUPNAsEmail: true,
+    });
+
+    const microsoftOauth: MicrosoftAuthConfiguration = { clientID, clientSecret, tenant, callbackURL, redirectURL };
+    if (!isMicrosoftOAuthConfigured(microsoftOauth)) {
+      this.logger.debug('Microsoft OAuth strategy is not configured');
+    }
+  }
+
+  async validate(_accessToken: string, _refreshToken: string, profile: any, done: any): Promise<any> {
+    const { id, displayName, emails, photos } = profile;
+
+    // generate a unique access code. 
+    const loginAccessCode: string = uuid();
+
+    // Handle email fallback logic within the standard validate flow
+    const email = emails?.[0]?.value || profile._json?.mail || profile._json?.userPrincipalName;
+
+    const user = {
+      provider: 'microsoft',
+      providerId: id,
+      email: email,
+      name: displayName,
+      picture: photos?.[0]?.value || null,
+      accessCode: loginAccessCode,
+    };
+
+    // store the access code and the access token in the database. 
+    await this.userService.resolveUserOnOauthMicrosoft({ 
+        ...user, 
+        accessToken: _accessToken, 
+        refreshToken: null 
+    });
+
+    done(null, user);
+  }
+}

package/src/repository/chatter-message-details.repository.ts

@@ -4,7 +4,8 @@ import {
   QueryRunner,
   SelectQueryBuilder,
 } from 'typeorm';
-import { camelize, classify } from '@angular-devkit/core/src/utils/strings';
+import { upperFirst, camelCase } from 'lodash';
+import { classify } from '../helpers/string.helper';
 
 import { ChatterMessageDetails } from 'src/entities/chatter-message-details.entity';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
@@ -80,7 +81,7 @@ export class ChatterMessageDetailsRepository extends SolidBaseRepository<Chatter
     const entityName = classify(coModelName);                 // "client" -> "Client"
     const meta = this.dataSource.getMetadata(entityName);     // throws if not registered
     // const table = meta.tablePath;                             // schema-qualified
-    const coAlias = camelize(meta.name);                      // stable alias, e.g., "client"
+    const coAlias = camelCase(meta.name);                      // stable alias, e.g., "client"
 
     // LEFT JOIN "<schema>"."<table>" "<coAlias>"
     //   ON "<coAlias>"."id" = "message"."co_model_entity_id"
@@ -103,7 +104,7 @@ export class ChatterMessageDetailsRepository extends SolidBaseRepository<Chatter
     const coModelName = get(requestFilter, this.CO_MODEL_NAME_PATH);
     if (!coModelName) return [undefined, undefined];
 
-    const alias = camelize(coModelName);
+    const alias = camelCase(coModelName);
     return [coModelName, alias];
   }
 

package/src/repository/chatter-message.repository.ts

@@ -1,4 +1,3 @@
-import { camelize, classify } from "@angular-devkit/core/src/utils/strings";
 import { Injectable } from "@nestjs/common";
 import { ChatterMessage } from "src/entities/chatter-message.entity";
 import { ActiveUserData } from "src/interfaces/active-user-data.interface";
@@ -6,7 +5,8 @@ import { RequestContextService } from "src/services/request-context.service";
 import { DataSource, QueryRunner, SelectQueryBuilder } from "typeorm";
 import { SecurityRuleRepository } from "./security-rule.repository";
 import { SolidBaseRepository } from "./solid-base.repository";
-import {get} from "lodash"
+import { get, camelCase } from 'lodash';
+import { classify } from '../helpers/string.helper';
 
 @Injectable()
 export class ChatterMessageRepository extends SolidBaseRepository<ChatterMessage> {
@@ -44,7 +44,7 @@ export class ChatterMessageRepository extends SolidBaseRepository<ChatterMessage
         // const Target = resolveEntityFromCoModelName(coModelName); // your mapping
         const entityName = classify(coModelName)
         const meta = this.dataSource.getMetadata(entityName);
-        const alias = camelize(meta.name);
+        const alias = camelCase(meta.name);
         qb.leftJoin(
             entityName,
             alias,
@@ -63,7 +63,7 @@ export class ChatterMessageRepository extends SolidBaseRepository<ChatterMessage
 
         const coModelName = get(requestFilter, this.CO_MODEL_NAME_PATH);
         if (!coModelName) return [undefined, undefined];
-        const alias = camelize(coModelName);
+        const alias = camelCase(coModelName);
         return [coModelName, alias];
     }
 

package/src/repository/solid-base.repository.ts

@@ -1,4 +1,4 @@
-import { camelize } from '@angular-devkit/core/src/utils/strings';
+import { camelCase } from 'lodash';
 import { Logger } from '@nestjs/common';
 import { CommonEntity } from 'src/entities/common.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
@@ -33,7 +33,7 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
     }
 
     modelSingularName(): string {
-        return camelize(this.metadata.name);
+        return camelCase(this.metadata.name);
     }
 
     async findOneByUserKey(userKeyValue: string | number): Promise<T | null> {

package/src/seeders/module-test-data.service.ts

@@ -1,7 +1,7 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from '@nestjs/core';
 import { getDataSourceToken } from '@nestjs/typeorm';
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify } from '../helpers/string.helper';
 import { DataSource, EntityManager } from 'typeorm';
 import * as fs from 'fs';
 import * as path from 'path';

package/src/seeders/seed-data/solid-core-metadata.json

@@ -1511,7 +1511,7 @@
             "encrypt": false,
             "relationType": "many-to-many",
             "relationCoModelSingularName": "roleMetadata",
-            "relationCoModelFieldName": "users",
+            "relationCoModelFieldName": "menuItems",
             "relationCreateInverse": true,
             "relationCascade": "set null",
             "relationModelModuleName": "solid-core",
@@ -3780,7 +3780,9 @@
               "audit_insert:audit_insert",
               "audit_update:audit_update",
               "audit_delete:audit_delete",
-              "custom:custom"
+              "custom:custom",
+              "note:note",
+              "task:task"
             ]
           },
           {
@@ -3891,6 +3893,21 @@
             "private": false,
             "encrypt": false,
             "isSystem": false
+          },
+          {
+            "name": "status",
+            "displayName": "Message Status",
+            "type": "selectionStatic",
+            "defaultValue": "pending",
+            "length": 256,
+            "required": true,
+            "index": false,
+            "isSystem": false,
+            "selectionValueType": "string",
+            "selectionStaticValues": [
+              "pending:pending",
+              "completed:completed"
+            ]
           }
         ]
       },
@@ -5907,7 +5924,8 @@
   },
   "permissions": [
     "mcp:invoke",
-    "agent:invoke"
+    "agent:invoke",
+    "settings:view_encrypted"
   ],
   "roles": [
     {
@@ -5951,6 +5969,7 @@
         "ChatterMessageController.getChatterMessages",
         "ChatterMessageController.postMessage",
         "ChatterMessageController.findMany",
+        "ChatterMessageController.markCompleted",
         "ImportTransactionController.getImportTemplate",
         "ImportTransactionController.getImportInstructions",
         "ImportTransactionController.getImportMappingInfo",
@@ -6408,38 +6427,12 @@
       "modelUserKey": "userActivityHistory"
     },
     {
-      "displayName": "App Settings",
-      "name": "appSettings-action",
-      "type": "custom",
-      "domain": "",
-      "context": "",
-      "customComponent": "/admin/core/solid-core/settings/app-settings",
-      "customIsModal": true,
-      "serverEndpoint": "",
-      "viewUserKey": "",
-      "moduleUserKey": "solid-core",
-      "modelUserKey": "setting"
-    },
-    {
-      "displayName": "Authentication Settings Action",
-      "name": "authenticationSettings-action",
-      "type": "custom",
-      "domain": "",
-      "context": "",
-      "customComponent": "/admin/core/solid-core/settings/authentication-settings",
-      "customIsModal": true,
-      "serverEndpoint": "",
-      "viewUserKey": "",
-      "moduleUserKey": "solid-core",
-      "modelUserKey": "setting"
-    },
-    {
-      "displayName": "Misc Action",
-      "name": "miscSettings-action",
+      "displayName": "Settings",
+      "name": "settings-action",
       "type": "custom",
       "domain": "",
       "context": "",
-      "customComponent": "/admin/core/solid-core/settings/misc-settings",
+      "customComponent": "/admin/core/settings",
       "customIsModal": true,
       "serverEndpoint": "",
       "viewUserKey": "",
@@ -6920,35 +6913,11 @@
       "displayName": "Settings",
       "name": "settings-menu-item",
       "sequenceNumber": 9,
-      "actionUserKey": "",
+      "actionUserKey": "settings-action",
       "moduleUserKey": "solid-core",
       "parentMenuItemUserKey": "",
       "iconName": "settings"
     },
-    {
-      "displayName": "App Settings",
-      "name": "appSettings-menu-item",
-      "sequenceNumber": 1,
-      "actionUserKey": "appSettings-action",
-      "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": "settings-menu-item"
-    },
-    {
-      "displayName": "Authentication Settings",
-      "name": "authenticationSettings-menu-item",
-      "sequenceNumber": 2,
-      "actionUserKey": "authenticationSettings-action",
-      "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": "settings-menu-item"
-    },
-    {
-      "displayName": "Misc",
-      "name": "miscSettings-menu-item",
-      "sequenceNumber": 3,
-      "actionUserKey": "miscSettings-action",
-      "moduleUserKey": "solid-core",
-      "parentMenuItemUserKey": "settings-menu-item"
-    },
     {
       "displayName": "Model Sequence",
       "name": "modelSequence-menu-item",
@@ -10518,7 +10487,7 @@
           "edit": true,
           "delete": true,
           "groupBy": "stage",
-          "draggable": true,
+          "draggable": false,
           "allowedViews": [
             "list",
             "kanban"

package/src/services/api-key.service.ts

@@ -6,6 +6,7 @@ import {
     UnauthorizedException,
 } from '@nestjs/common';
 import { createHash, randomBytes } from 'crypto';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { CreateApiKeyDto } from 'src/dtos/create-api-key.dto';
 import { UpdateApiKeyDto } from 'src/dtos/update-api-key.dto';
 import { UserApiKey } from 'src/entities/user-api-key.entity';
@@ -13,6 +14,8 @@ import { User } from 'src/entities/user.entity';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { UserApiKeyRepository } from 'src/repository/user-api-key.repository';
 import { PermissionMetadataService } from 'src/services/permission-metadata.service';
+import { AuthenticationService } from './authentication.service';
+import { UserRepository } from 'src/repository/user.repository';
 
 @Injectable()
 export class ApiKeyService {
@@ -21,53 +24,55 @@ export class ApiKeyService {
     constructor(
         private readonly apiKeyRepository: UserApiKeyRepository,
         private readonly permissionMetadataService: PermissionMetadataService,
+        private readonly authenticationService: AuthenticationService,
+        private readonly userRepository: UserRepository,
     ) {}
 
-    async generate(userId: number, dto: CreateApiKeyDto): Promise<{ apiKey: string; record: UserApiKey }> {
-        const user = await this.apiKeyRepository.manager.findOne(User, {
-            where: { id: userId },
-            select: ['id', 'isAllowedToGenerateApiKeys'],
-        });
+    async generate(userId: number, dto: CreateApiKeyDto): Promise < { apiKey: string; record: UserApiKey } > {
+            const user = await this.apiKeyRepository.manager.findOne(User, {
+                where: { id: userId },
+                select: ['id', 'isAllowedToGenerateApiKeys'],
+            });
 
-        if (!user?.isAllowedToGenerateApiKeys) {
-            throw new ForbiddenException('You are not allowed to generate API keys');
-        }
+            if(!user?.isAllowedToGenerateApiKeys) {
+                throw new ForbiddenException('You are not allowed to generate API keys');
+            }
 
         const rawKey = 'sldx_' + randomBytes(32).toString('hex');
-        const hashedKey = this.hash(rawKey);
-        const maskedKey = 'sldx_****' + rawKey.slice(-4);
-
-        const record = this.apiKeyRepository.create({
-            name: dto.name,
-            hashedKey,
-            maskedKey,
-            isActive: true,
-            expiresAt: dto.expiresAt ? new Date(dto.expiresAt) : null,
-            user,
-        });
+            const hashedKey = this.hash(rawKey);
+            const maskedKey = 'sldx_****' + rawKey.slice(-4);
 
-        await this.apiKeyRepository.save(record);
+            const record = this.apiKeyRepository.create({
+                name: dto.name,
+                hashedKey,
+                maskedKey,
+                isActive: true,
+                expiresAt: dto.expiresAt ? new Date(dto.expiresAt) : null,
+                user,
+            });
 
-        // Strip hashedKey from the returned record — maskedKey is all the UI needs
-        delete (record as any).hashedKey;
+            await this.apiKeyRepository.save(record);
 
-        return { apiKey: rawKey, record };
-    }
+            // Strip hashedKey from the returned record — maskedKey is all the UI needs
+            delete(record as any).hashedKey;
 
-    async validate(rawKey: string): Promise<ActiveUserData> {
-        const hashedKey = this.hash(rawKey);
+            return { apiKey: rawKey, record };
+        }
 
-        // Bypass security rules for auth validation — must find the key regardless of caller context
-        const keyRecord = await this.apiKeyRepository.findOne({
-            where: { hashedKey, isActive: true },
-            relations: ['user', 'user.roles'],
-        });
+    async validate(rawKey: string): Promise < ActiveUserData > {
+            const hashedKey = this.hash(rawKey);
 
-        if (!keyRecord) {
-            throw new UnauthorizedException();
-        }
+            // Bypass security rules for auth validation — must find the key regardless of caller context
+            const keyRecord = await this.apiKeyRepository.findOne({
+                where: { hashedKey, isActive: true },
+                relations: ['user', 'user.roles'],
+            });
 
-        if (keyRecord.expiresAt && keyRecord.expiresAt < new Date()) {
+            if(!keyRecord) {
+                throw new UnauthorizedException();
+            }
+
+        if(keyRecord.expiresAt && keyRecord.expiresAt < new Date()) {
             throw new UnauthorizedException('API key expired');
         }
 
@@ -105,6 +110,43 @@ export class ApiKeyService {
             .execute();
     }
 
+
+    async apiKeyMe(apiKey: string) {
+
+        const hasedKey = this.hash(apiKey);
+        const apiKeyRecord = await this.apiKeyRepository.findOne({
+            where: {
+                hashedKey: hasedKey,
+            },
+            relations: {
+                user: {
+                    roles: true
+                }
+            }
+        });
+
+        if (!apiKeyRecord) {
+            throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+        }
+
+        const user = apiKeyRecord.user;
+
+        const tokens = await this.authenticationService.generateTokens(user);
+
+
+        return {
+            user: {
+                email: user.email,
+                mobile: user.mobile,
+                username: user.username,
+                forcePasswordChange: user.forcePasswordChange,
+                id: user.id,
+                roles: user.roles.map((role) => role.name)
+            },
+            ...tokens
+        }
+    }
+
     private hash(rawKey: string): string {
         return createHash('sha256').update(rawKey).digest('hex');
     }