@solidxai/core 0.1.8-beta.0 → 0.1.8-beta.10

package/src/dtos/create-agent-session.dto.ts

@@ -0,0 +1,64 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsDate, IsInt, IsNotEmpty, IsNumber, IsOptional, IsString } from 'class-validator';
+
+export class CreateAgentSessionDto {
+  @IsNotEmpty()
+  @IsString()
+  @ApiProperty()
+  sessionId: string;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  userId: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  projectRoot: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @ApiProperty()
+  modelName: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @ApiProperty()
+  status: string;
+
+  @IsOptional()
+  @IsNumber()
+  @ApiProperty()
+  totalCost: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  totalSteps: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  totalInputTokens: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  totalOutputTokens: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  summary: string;
+
+  @IsOptional()
+  @IsDate()
+  @ApiProperty()
+  createdAt: Date;
+
+  @IsOptional()
+  @IsDate()
+  @ApiProperty()
+  updatedAt: Date;
+}

package/src/dtos/create-api-key.dto.ts

@@ -0,0 +1,14 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDateString, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class CreateApiKeyDto {
+    @ApiProperty({ example: 'Production Server' })
+    @IsString()
+    @IsNotEmpty()
+    name: string;
+
+    @ApiPropertyOptional({ example: '2027-01-01T00:00:00.000Z' })
+    @IsDateString()
+    @IsOptional()
+    expiresAt?: string;
+}

package/src/dtos/post-chatter-message.dto.ts

@@ -16,4 +16,8 @@ export class PostChatterMessageDto {
     @IsString()
     @IsOptional()
     messageSubType?: string;
+
+    @IsString()
+    @IsOptional()
+    modelUserKey?: string;
 }

package/src/dtos/register-private.dto.ts

@@ -1,17 +1,8 @@
-import { IsEmail, IsNotEmpty, IsOptional, MinLength } from 'class-validator';
-
-export class RegisterPrivateDto {
-    @IsNotEmpty()
-    username: string;
-
-    @IsEmail()
-    @IsNotEmpty()
-    email: string;
-
-    @IsOptional()
-    mobile?: string;
+import { IsBoolean, IsOptional } from 'class-validator';
+import { SignUpDto } from './sign-up.dto';
 
+export class RegisterPrivateDto extends SignUpDto {
+    @IsBoolean()
     @IsOptional()
-    @MinLength(10)
-    password?: string;
+    isAllowedToGenerateApiKeys?: boolean;
 }

package/src/dtos/sso-exchange.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class SsoExchangeDto {
+    @IsNotEmpty()
+    @IsString()
+    code: string;
+}

package/src/dtos/update-agent-event.dto.ts

@@ -0,0 +1,83 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsInt, IsNumber, IsOptional, IsString } from 'class-validator';
+
+export class UpdateAgentEventDto {
+  @IsOptional()
+  @IsInt()
+  id: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  sessionId: string;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  turnNumber: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  stepNumber: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  eventType: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  eventData: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  content: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  toolName: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  toolArguments: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  toolOutput: string;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  toolReturncode: number;
+
+  @IsOptional()
+  @IsNumber()
+  @ApiProperty()
+  durationMs: number;
+
+  @IsOptional()
+  @IsNumber()
+  @ApiProperty()
+  cost: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  inputTokens: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  outputTokens: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  modelUsed: string;
+}

package/src/dtos/update-agent-session.dto.ts

@@ -0,0 +1,63 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsDate, IsInt, IsNumber, IsOptional, IsString } from 'class-validator';
+
+export class UpdateAgentSessionDto {
+  @IsOptional()
+  @IsInt()
+  id: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  sessionId: string;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  userId: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  projectRoot: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  modelName: string;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  status: string;
+
+  @IsOptional()
+  @IsNumber()
+  @ApiProperty()
+  totalCost: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  totalSteps: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  totalInputTokens: number;
+
+  @IsOptional()
+  @IsInt()
+  @ApiProperty()
+  totalOutputTokens: number;
+
+  @IsOptional()
+  @IsString()
+  @ApiProperty()
+  summary: string;
+
+  @IsOptional()
+  @IsDate()
+  @ApiProperty()
+  updatedAt: Date;
+}

package/src/dtos/update-api-key.dto.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsBoolean, IsNotEmpty } from 'class-validator';
+
+export class UpdateApiKeyDto {
+    @ApiProperty({ example: true })
+    @IsBoolean()
+    @IsNotEmpty()
+    isActive: boolean;
+}

package/src/entities/agent-event.entity.ts

@@ -0,0 +1,54 @@
+import { Column, Entity, Index } from 'typeorm';
+import { CommonEntity } from 'src/entities/common.entity';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
+
+@Entity({ name: 'ss_agent_events' })
+export class AgentEvent extends CommonEntity {
+  @Index()
+  @Column({ })
+  sessionId: string;
+
+  @Column({ })
+  turnNumber: number;
+
+  @Column({ nullable: true })
+  stepNumber: number;
+
+  @Index()
+  @Column({ })
+  eventType: string;
+
+  @Column({ type: "simple-json", nullable: true, ...getColumnType('simpleJsonLargeText') })
+  eventData: any;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  content: string;
+
+  @Index()
+  @Column({ nullable: true })
+  toolName: string;
+
+  @Column({ type: "simple-json", nullable: true, ...getColumnType('simpleJsonLargeText') })
+  toolArguments: string;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  toolOutput: string;
+
+  @Column({ nullable: true })
+  toolReturncode: number;
+
+  @Column({ nullable: true, ...getColumnType('decimal') })
+  durationMs: number;
+
+  @Column({ nullable: true, ...getColumnType('decimal') })
+  cost: number;
+
+  @Column({ nullable: true })
+  inputTokens: number;
+
+  @Column({ nullable: true })
+  outputTokens: number;
+
+  @Column({ nullable: true })
+  modelUsed: string;
+}

package/src/entities/agent-session.entity.ts

@@ -0,0 +1,39 @@
+import { Column, Entity, Index } from 'typeorm';
+import { CommonEntity } from 'src/entities/common.entity';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
+
+@Entity({ name: 'ss_agent_sessions' })
+export class AgentSession extends CommonEntity {
+  @Index({ unique: true })
+  @Column({ })
+  sessionId: string;
+
+  @Index()
+  @Column({ nullable: true })
+  userId: number;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  projectRoot: string;
+
+  @Column({ })
+  modelName: string;
+
+  @Index()
+  @Column({ })
+  status: string;
+
+  @Column({ default: 0, ...getColumnType('decimal') })
+  totalCost: number;
+
+  @Column({ default: 0 })
+  totalSteps: number;
+
+  @Column({ default: 0 })
+  totalInputTokens: number;
+
+  @Column({ default: 0 })
+  totalOutputTokens: number;
+
+  @Column({ nullable: true, ...getColumnType('longText') })
+  summary: string;
+}

package/src/entities/field-metadata.entity.ts

@@ -119,7 +119,7 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'selection_static_values', nullable: true, type: 'simple-array' })
     selectionStaticValues: string[];
 
-    @Column({ name: 'selection_value_type', nullable: true })
+    @Column({ name: 'selection_value_type', nullable: true, default: 'string' })
     selectionValueType: string = 'string';
 
     // @Column({ name: "computed", default: false })

package/src/entities/legacy-common.entity.ts

@@ -11,30 +11,30 @@ export abstract class LegacyCommonEntity {
     // @Generated("increment")
     // id: number
 
-    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at`, transformer: LocalDateTimeTransformer })
-    createdAt: Date;
+    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at`, transformer: LocalDateTimeTransformer, nullable: true })
+    createdAt: Date | null;
 
-    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at`, transformer: LocalDateTimeTransformer })
-    updatedAt: Date;
+    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at`, transformer: LocalDateTimeTransformer, nullable: true })
+    updatedAt: Date | null;
 
-    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at`, transformer: LocalDateTimeTransformer })
+    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at`, transformer: LocalDateTimeTransformer, nullable: true })
     @Index()
-    deletedAt: Date;
+    deletedAt: Date | null;
 
-    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_tracker`, default: "not-deleted" })
-    deletedTracker: string;
+    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_tracker`, default: "not-deleted", nullable: true })
+    deletedTracker: string | null;
 
     @Expose()
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_published_at`, default: null, nullable: true, transformer: LocalDateTimeTransformer })
-    publishedAt: Date;
+    publishedAt: Date | null;
 
     @Expose()
-    @Column({ type: "varchar", name: `${LEGACY_TABLE_FIELDS_PREFIX}_locale_name`, default: null })
-    localeName: string;
+    @Column({ type: "varchar", name: `${LEGACY_TABLE_FIELDS_PREFIX}_locale_name`, default: null, nullable: true })
+    localeName: string | null;
 
     @Expose()
-    @Column({ type: "int", name: `${LEGACY_TABLE_FIELDS_PREFIX}_default_entity_locale_id`, default: null })
-    defaultEntityLocaleId: number;
+    @Column({ type: "int", name: `${LEGACY_TABLE_FIELDS_PREFIX}_default_entity_locale_id`, default: null, nullable: true })
+    defaultEntityLocaleId: number | null;
 
     // @Expose()
     // @Type( () => require('./user.entity').User?.default ?? require('./user.entity').User )
@@ -50,9 +50,9 @@ export abstract class LegacyCommonEntity {
 
     @Expose()
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_by_id`, nullable: true })
-    createdBy: number;
+    createdBy: number | null;
 
     @Expose()
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_by_id`, nullable: true })
-    updatedBy: number;
+    updatedBy: number | null;
 }

package/src/entities/sms-template.entity.ts

@@ -1,14 +1,15 @@
 import { CommonEntity } from 'src/entities/common.entity';
 import { Column, Entity, Index } from 'typeorm';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_sms_template")
 export class SmsTemplate extends CommonEntity {
     @Index({ unique: true })
-    @Column({ name: "name", type: "varchar"})
+    @Column({ name: "name", type: "varchar" })
     name: string;
     @Column({ name: "display_name", type: "varchar" })
     displayName: string;
-    @Column({ name: "body", type: "varchar", nullable: true })
+    @Column({ name: "body", ...getColumnType('longText'), nullable: true })
     body: string;
     @Column({ type: "varchar", nullable: true })
     smsProviderTemplateId: string;

package/src/entities/user-api-key.entity.ts

@@ -0,0 +1,37 @@
+import { Exclude, Expose } from "class-transformer";
+import { CommonEntity } from "src/entities/common.entity";
+import { Column, Entity, Index, ManyToOne } from "typeorm";
+import { User } from "./user.entity";
+
+@Entity("ss_user_api_key")
+@Exclude()
+export class UserApiKey extends CommonEntity {
+
+    @Expose()
+    @Column()
+    name: string;
+
+    // SHA-256 hash of the raw key — never exposed, same treatment as User.password
+    @Index({ unique: true })
+    @Column()
+    hashedKey: string;
+
+    @Expose()
+    @Column()
+    maskedKey: string;
+
+    @Expose()
+    @Column({ default: true })
+    isActive: boolean;
+
+    @Expose()
+    @Column({ nullable: true })
+    expiresAt: Date;
+
+    @Expose()
+    @Column({ nullable: true })
+    lastUsedAt: Date;
+
+    @ManyToOne(() => User, user => user.apiKeys)
+    user: User;
+}

package/src/entities/user.entity.ts

@@ -2,6 +2,7 @@ import { CommonEntity } from "src/entities/common.entity"
 import { Entity, Column, Index, JoinTable, ManyToMany, OneToMany, TableInheritance } from "typeorm";
 import { RoleMetadata } from 'src/entities/role-metadata.entity';
 import { UserViewMetadata } from 'src/entities/user-view-metadata.entity'
+import { UserApiKey } from 'src/entities/user-api-key.entity'
 import { Exclude, Expose } from "class-transformer";
 
 @Entity("ss_user")
@@ -151,4 +152,11 @@ export class User extends CommonEntity {
     @Expose()
     _media: any;
 
+    @Column({ default: false })
+    @Expose()
+    isAllowedToGenerateApiKeys: boolean = false;
+
+    @OneToMany(() => UserApiKey, key => key.user)
+    apiKeys: UserApiKey[];
+
 }

package/src/enums/auth-type.enum.ts

@@ -1,4 +1,5 @@
 export enum AuthType {
     Bearer,
+    ApiKey,
     None,
 }

package/src/guards/api-key.guard.ts

@@ -0,0 +1,32 @@
+import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
+import { Request } from 'express';
+import { REQUEST_USER_KEY } from 'src/constants';
+import { ApiKeyService } from 'src/services/api-key.service';
+import { ClsService } from 'nestjs-cls';
+
+@Injectable()
+export class ApiKeyGuard implements CanActivate {
+    constructor(
+        private readonly apiKeyService: ApiKeyService,
+        private readonly cls: ClsService,
+    ) {}
+
+    async canActivate(context: ExecutionContext): Promise<boolean> {
+        const request = context.switchToHttp().getRequest<Request>();
+        const rawKey = this.extractKeyFromHeader(request);
+
+        if (!rawKey) {
+            throw new UnauthorizedException();
+        }
+
+        const activeUser = await this.apiKeyService.validate(rawKey);
+        request[REQUEST_USER_KEY] = activeUser;
+        this.cls.set(REQUEST_USER_KEY, activeUser);
+
+        return true;
+    }
+
+    private extractKeyFromHeader(request: Request): string | undefined {
+        return request.headers['solidx-api-key'] as string | undefined;
+    }
+}

package/src/guards/authentication.guard.ts

@@ -8,23 +8,26 @@ import { Reflector } from '@nestjs/core';
 import { AUTH_TYPE_KEY } from '../decorators/auth.decorator';
 import { AuthType } from '../enums/auth-type.enum';
 import { AccessTokenGuard } from './access-token.guard';
+import { ApiKeyGuard } from './api-key.guard';
 import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
 import { PermissionMetadataService } from '../services/permission-metadata.service';
 import { ClsService } from 'nestjs-cls';
 
 @Injectable()
 export class AuthenticationGuard implements CanActivate {
-  private static readonly defaultAuthType = AuthType.Bearer;
+  private static readonly defaultAuthTypes = [AuthType.Bearer, AuthType.ApiKey];
   private readonly authTypeGuardMap: Record<
     AuthType,
     CanActivate | CanActivate[]> = {
       [AuthType.Bearer]: this.accessTokenGuard,
+      [AuthType.ApiKey]: this.apiKeyGuard,
       [AuthType.None]: { canActivate: () => true },
     };
 
   constructor(
     private readonly reflector: Reflector,
     private readonly accessTokenGuard: AccessTokenGuard,
+    private readonly apiKeyGuard: ApiKeyGuard,
     private readonly permissionService: PermissionMetadataService,
     private readonly cls: ClsService,
   ) { }
@@ -49,7 +52,7 @@ export class AuthenticationGuard implements CanActivate {
       return true;
     }
 
-    // TODO: Check if this permission viz. contextPermission is listed in the Public role. 
+    // TODO: Check if this permission viz. contextPermission is listed in the Public role.
     const contextPermission = `${context.getClass().name}.${context.getHandler().name}`;
 
     const permissionExistsInRole = await this.permissionService.permissionExistsInRole('Public', contextPermission)
@@ -61,7 +64,7 @@ export class AuthenticationGuard implements CanActivate {
     const authTypes = this.reflector.getAllAndOverride<AuthType[]>(
       AUTH_TYPE_KEY,
       [context.getHandler(), context.getClass()],
-    ) ?? [AuthenticationGuard.defaultAuthType];
+    ) ?? AuthenticationGuard.defaultAuthTypes;
     const guards = authTypes.map((type) => this.authTypeGuardMap[type]).flat();
     let error = new UnauthorizedException();
 

package/src/helpers/bootstrap.helper.ts

@@ -90,6 +90,21 @@ export async function bootstrapSolidApp(
   // Security headers
   app.use(helmet(buildDefaultSecurityHeaderOptions()));
 
+  // Nest's Swagger UI HTML injects inline styles; keep CSP strict elsewhere.
+  const isSwaggerPath = (path: string) =>
+    path === '/docs' ||
+    path === '/docs/' ||
+    path.startsWith('/docs/') ||
+    path === '/docs-json' ||
+    path === '/docs-yaml';
+
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    if (isSwaggerPath(req.path)) {
+      res.removeHeader('Content-Security-Policy');
+    }
+    next();
+  });
+
   // Permissions-Policy header
   app.use((_req: Request, res: Response, next: NextFunction) => {
     res.setHeader('Permissions-Policy', buildPermissionsPolicyHeader(permissionsPolicyOverrides));
@@ -127,7 +142,7 @@ export async function bootstrapSolidApp(
 
   // Swagger
   if (swagger !== false) {
-    const { title = 'Solid Starters', description = 'Solid Starters API', version = '1.0' } = swagger;
+    const { title = process.env.SOLID_APP_NAME, description = process.env.SOLID_APP_DESCRIPTION, version = '1.0' } = swagger;
     const swaggerConfig = new DocumentBuilder()
       .setTitle(title)
       .setDescription(description)

package/src/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -128,14 +128,25 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
     }
 
     private providerInstance<T extends ISelectionProviderContext>(selectionDynamicProvider: string): ISelectionProvider<T> {
-        const provider = this.options.discoveryService
-            .getProviders()
-            .filter((provider) => provider.name === selectionDynamicProvider)
-            .pop();
-        if (!provider) {
+        const providers = this.options.discoveryService.getProviders();
+
+        const byToken = providers.find((p) => p.name === selectionDynamicProvider);
+        if (byToken) {
+            return byToken.instance as ISelectionProvider<T>;
+        }
+
+        const byName = providers.find((p) => {
+            try {
+                return typeof p.instance?.name === 'function' && p.instance.name() === selectionDynamicProvider;
+            } catch {
+                return false;
+            }
+        });
+
+        if (!byName) {
             throw new Error(`Provider for ${selectionDynamicProvider} not found`);
         }
-        return provider.instance as ISelectionProvider<T>;
+        return byName.instance as ISelectionProvider<T>;
     }
 
     private isApplyRequiredValidation(): boolean {