@hexabot-ai/api 3.0.0-alpha.3

package/src/user/dto/permission.dto.ts

@@ -0,0 +1,87 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { ApiProperty } from '@nestjs/swagger';
+import { Exclude, Expose, Type } from 'class-transformer';
+import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+import { IsUUIDv4 } from '@/utils/decorators/is-uuid.decorator';
+import {
+  BaseStub,
+  DtoActionConfig,
+  DtoTransformerConfig,
+} from '@/utils/types/dto.types';
+
+import { Action } from '../types/action.type';
+import { TRelation } from '../types/index.type';
+
+import { Model } from './model.dto';
+import { Role } from './role.dto';
+
+@Exclude()
+export class PermissionStub extends BaseStub {
+  @Expose()
+  action: string;
+
+  @Expose()
+  relation: TRelation;
+}
+
+@Exclude()
+export class Permission extends PermissionStub {
+  @Expose({ name: 'modelId' })
+  model: string;
+
+  @Expose({ name: 'roleId' })
+  role: string;
+}
+
+@Exclude()
+export class PermissionFull extends PermissionStub {
+  @Expose()
+  @Type(() => Model)
+  model: Model;
+
+  @Expose()
+  @Type(() => Role)
+  role: Role;
+}
+
+export class PermissionCreateDto {
+  @ApiProperty({ description: 'Id of the model', type: String })
+  @IsNotEmpty()
+  @IsString()
+  @IsUUIDv4({ message: 'Model must be a valid UUID' })
+  model: string;
+
+  @ApiProperty({ description: 'Action to perform on the model', enum: Action })
+  @IsNotEmpty()
+  @IsEnum(Action)
+  action: Action;
+
+  @IsNotEmpty()
+  @ApiProperty({ description: 'Id of the role', type: String })
+  @IsString()
+  @IsUUIDv4({ message: 'Role must be a valid UUID' })
+  role: string;
+
+  @ApiProperty({
+    description: 'relation of the permission',
+    type: String,
+  })
+  @IsString()
+  @IsOptional()
+  relation?: TRelation;
+}
+
+export type PermissionTransformerDto = DtoTransformerConfig<{
+  PlainCls: typeof Permission;
+  FullCls: typeof PermissionFull;
+}>;
+
+export type PermissionDtoConfig = DtoActionConfig<{
+  create: PermissionCreateDto;
+}>;

package/src/user/dto/role.dto.ts

@@ -0,0 +1,78 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { Exclude, Expose, Type } from 'class-transformer';
+import { IsBoolean, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+import {
+  BaseStub,
+  DtoActionConfig,
+  DtoTransformerConfig,
+} from '@/utils/types/dto.types';
+
+import { Permission } from './permission.dto';
+import { User } from './user.dto';
+
+@Exclude()
+export class RoleStub extends BaseStub {
+  @Expose()
+  id!: string;
+
+  @Expose()
+  code!: string;
+
+  @Expose()
+  label!: string;
+
+  @Expose()
+  name!: string;
+
+  @Expose()
+  active!: boolean;
+}
+
+@Exclude()
+export class Role extends RoleStub {}
+
+@Exclude()
+export class RoleFull extends RoleStub {
+  @Expose()
+  @Type(() => Permission)
+  permissions?: Permission[];
+
+  @Expose()
+  @Type(() => User)
+  users: User[];
+}
+
+export class RoleCreateDto {
+  @ApiProperty({ description: 'Name of the role', type: String })
+  @IsNotEmpty()
+  @IsString()
+  name: string;
+
+  @ApiPropertyOptional({
+    description: 'Is the role active',
+    type: String,
+    default: true,
+  })
+  @IsOptional()
+  @IsBoolean()
+  active?: boolean;
+}
+
+export class RoleUpdateDto extends PartialType(RoleCreateDto) {}
+
+export type RoleTransformerDto = DtoTransformerConfig<{
+  PlainCls: typeof Role;
+  FullCls: typeof RoleFull;
+}>;
+
+export type RoleDtoConfig = DtoActionConfig<{
+  create: RoleCreateDto;
+  update: RoleUpdateDto;
+}>;

package/src/user/dto/user.dto.ts

@@ -0,0 +1,228 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { PickType } from '@nestjs/mapped-types';
+import {
+  ApiProperty,
+  ApiPropertyOptional,
+  OmitType,
+  PartialType,
+} from '@nestjs/swagger';
+import { Exclude, Expose, Type } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsEmail,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+} from 'class-validator';
+
+import { Attachment } from '@/attachment/dto/attachment.dto';
+import { IsUUIDv4 } from '@/utils/decorators/is-uuid.decorator';
+import {
+  BaseStub,
+  DtoActionConfig,
+  DtoTransformerConfig,
+} from '@/utils/types/dto.types';
+
+import { UserProvider } from '../types/user-provider.type';
+
+import { Role } from './role.dto';
+
+@Exclude()
+export class UserStub extends BaseStub {
+  @Expose()
+  username!: string;
+
+  @Expose()
+  first_name!: string;
+
+  @Expose()
+  last_name!: string;
+
+  @Expose()
+  email!: string;
+
+  @Expose()
+  sendEmail!: boolean;
+
+  @Expose()
+  state!: boolean;
+
+  @Expose()
+  language!: string;
+
+  @Expose()
+  timezone!: string;
+
+  @Expose()
+  resetCount!: number;
+
+  @Expose()
+  resetToken!: string | null;
+
+  @Expose()
+  provider?: UserProvider;
+}
+
+@Exclude()
+export class User extends UserStub {
+  @Expose({ name: 'roleIds' })
+  roles: string[];
+
+  @Expose({ name: 'avatarId' })
+  avatar: string;
+}
+
+@Exclude()
+export class UserFull extends UserStub {
+  @Expose()
+  @Type(() => Role)
+  roles: Role[];
+
+  @Expose()
+  @Type(() => Attachment)
+  avatar: Attachment | null;
+}
+
+export class UserCreateDto {
+  @ApiProperty({ description: 'User username', type: String })
+  @IsNotEmpty()
+  @IsString()
+  username: string;
+
+  @ApiProperty({ description: 'User first name', type: String })
+  @IsNotEmpty()
+  @IsString()
+  first_name: string;
+
+  @ApiProperty({ description: 'User last name', type: String })
+  @IsNotEmpty()
+  @IsString()
+  last_name: string;
+
+  @ApiProperty({ description: 'User email', type: String })
+  @IsNotEmpty()
+  @IsEmail()
+  email: string;
+
+  @ApiProperty({ description: 'User password', type: String })
+  @IsNotEmpty()
+  @IsString()
+  password: string;
+
+  @ApiProperty({ description: 'User roles', type: String })
+  @IsNotEmpty()
+  @IsArray()
+  @IsUUIDv4({ each: true, message: 'Role must be a valid UUID' })
+  roles: string[];
+
+  @ApiPropertyOptional({ description: 'Avatar', type: String })
+  @IsOptional()
+  @IsString()
+  @IsUUIDv4({ message: 'Avatar must be a valid UUID' })
+  avatar: string | null = null;
+
+  @ApiPropertyOptional({
+    description: 'User state',
+    type: Boolean,
+  })
+  @IsOptional()
+  @IsBoolean()
+  state?: boolean;
+}
+
+export class UserUpdateDto extends PartialType(UserCreateDto) {
+  @ApiPropertyOptional({ description: 'User language', type: String })
+  @IsOptional()
+  @IsString()
+  language?: string;
+
+  @ApiPropertyOptional({ description: 'User timezone', type: String })
+  @IsOptional()
+  @IsString()
+  timezone?: string;
+
+  @ApiPropertyOptional({
+    description: 'Send automated emails to the user',
+    type: Boolean,
+  })
+  @IsOptional()
+  @IsBoolean()
+  sendEmail?: boolean;
+
+  @ApiPropertyOptional({
+    description: 'Password reset token',
+    type: String,
+    nullable: true,
+  })
+  @IsOptional()
+  @IsString()
+  resetToken?: string | null;
+
+  @ApiPropertyOptional({
+    description: 'Password reset counter',
+    type: Number,
+  })
+  @IsOptional()
+  @IsInt()
+  resetCount?: number;
+
+  @ApiPropertyOptional({
+    description: 'Authentication provider metadata',
+    type: Object,
+  })
+  @IsOptional()
+  provider?: UserProvider;
+}
+
+export class UserEditProfileDto extends OmitType(UserUpdateDto, [
+  'username',
+  'roles',
+  'avatar',
+  'state',
+  'sendEmail',
+  'resetToken',
+  'resetCount',
+  'provider',
+]) {}
+
+export class UserUpdateStateAndRolesDto {
+  @ApiPropertyOptional({
+    description: 'User state',
+    type: Boolean,
+  })
+  @IsOptional()
+  @IsBoolean()
+  state?: boolean;
+
+  @ApiPropertyOptional({
+    description: 'User roles',
+    type: Boolean,
+  })
+  @IsOptional()
+  @IsArray()
+  @IsUUIDv4({ each: true, message: 'Role must be a valid UUID' })
+  roles?: string[];
+}
+
+export class UserResetPasswordDto extends PickType(UserCreateDto, [
+  'password',
+]) {}
+
+export class UserRequestResetDto extends PickType(UserCreateDto, ['email']) {}
+
+export type UserTransformerDto = DtoTransformerConfig<{
+  PlainCls: typeof User;
+  FullCls: typeof UserFull;
+}>;
+
+export type UserDtoConfig = DtoActionConfig<{
+  create: UserCreateDto;
+  update: UserUpdateDto;
+}>;

package/src/user/entities/invitation.entity.ts

@@ -0,0 +1,61 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  Entity,
+  JoinTable,
+  ManyToMany,
+  RelationId,
+} from 'typeorm';
+
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+import { AsRelation } from '@/utils/decorators/relation-ref.decorator';
+
+import { sha256Hash } from '../utilities/hash';
+
+import { RoleOrmEntity } from './role.entity';
+
+@Entity({ name: 'invitations' })
+export class InvitationOrmEntity extends BaseOrmEntity {
+  @Column({ type: 'varchar' })
+  email!: string;
+
+  @Column({ type: 'varchar' })
+  token!: string;
+
+  @ManyToMany(() => RoleOrmEntity)
+  @JoinTable({
+    name: 'invitation_roles',
+    joinColumn: { name: 'invitation_id' },
+    inverseJoinColumn: { name: 'role_id' },
+  })
+  @AsRelation({ allowArray: true })
+  roles!: RoleOrmEntity[];
+
+  @RelationId((invitation: InvitationOrmEntity) => invitation.roles)
+  private readonly roleIds!: string[];
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  private hashToken(): void {
+    if (!this.token) {
+      return;
+    }
+
+    if (InvitationOrmEntity.isHashed(this.token)) {
+      return;
+    }
+
+    this.token = sha256Hash(this.token);
+  }
+
+  private static isHashed(value: string): boolean {
+    return /^[A-Za-z0-9_-]{43}$/.test(value);
+  }
+}

package/src/user/entities/model.entity.ts

@@ -0,0 +1,36 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Column, Entity, Index, OneToMany } from 'typeorm';
+
+import { JsonColumn } from '@/database/decorators/json-column.decorator';
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+
+import { TRelation } from '../types/index.type';
+
+import { PermissionOrmEntity } from './permission.entity';
+
+@Entity({ name: 'models' })
+@Index(['name'], { unique: true })
+@Index(['identity'], { unique: true })
+export class ModelOrmEntity extends BaseOrmEntity {
+  @Column()
+  name!: string;
+
+  @Column()
+  identity!: string;
+
+  @JsonColumn({ default: '{}' })
+  attributes: Record<string, unknown>;
+
+  @Column({ nullable: true })
+  relation?: TRelation;
+
+  @OneToMany(() => PermissionOrmEntity, (permission) => permission.model, {
+    cascade: ['remove'],
+  })
+  permissions?: PermissionOrmEntity[];
+}

package/src/user/entities/permission.entity.ts

@@ -0,0 +1,54 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  Column,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  RelationId,
+} from 'typeorm';
+
+import { EnumColumn } from '@/database/decorators/enum-column.decorator';
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+import { AsRelation } from '@/utils/decorators/relation-ref.decorator';
+
+import { Action } from '../types/action.type';
+import { TRelation } from '../types/index.type';
+
+import { ModelOrmEntity } from './model.entity';
+import { RoleOrmEntity } from './role.entity';
+
+@Entity({ name: 'permissions' })
+@Index(['model', 'action', 'role', 'relation'], { unique: true })
+export class PermissionOrmEntity extends BaseOrmEntity {
+  @ManyToOne(() => ModelOrmEntity, (model) => model.permissions, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'model_id' })
+  @AsRelation()
+  model!: ModelOrmEntity;
+
+  @RelationId((permission: PermissionOrmEntity) => permission.model)
+  private readonly modelId!: string;
+
+  @EnumColumn({ enum: Action })
+  action!: Action;
+
+  @ManyToOne(() => RoleOrmEntity, (role) => role.permissions, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'role_id' })
+  @AsRelation()
+  role!: RoleOrmEntity;
+
+  @RelationId((permission: PermissionOrmEntity) => permission.role)
+  private readonly roleId!: string;
+
+  @Column({ default: 'role' })
+  relation!: TRelation;
+}

package/src/user/entities/role.entity.ts

@@ -0,0 +1,32 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Column, Entity, Index, ManyToMany, OneToMany } from 'typeorm';
+
+import { BaseOrmEntity } from '@/database/entities/base.entity';
+
+import { PermissionOrmEntity } from './permission.entity';
+import { UserOrmEntity } from './user.entity';
+
+export type TRole = 'admin' | 'public';
+
+@Entity({ name: 'roles' })
+@Index(['name'], { unique: true })
+export class RoleOrmEntity extends BaseOrmEntity {
+  @Column()
+  name!: string;
+
+  @Column({ default: true })
+  active!: boolean;
+
+  @OneToMany(() => PermissionOrmEntity, (permission) => permission.role, {
+    cascade: ['remove'],
+  })
+  permissions?: PermissionOrmEntity[];
+
+  @ManyToMany(() => UserOrmEntity, (user) => user.roles)
+  users?: UserOrmEntity[];
+}

package/src/user/entities/session.entity.ts

@@ -0,0 +1,30 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { ISession } from 'connect-typeorm';
+import {
+  Column,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  PrimaryColumn,
+} from 'typeorm';
+
+@Entity({ name: 'sessions' })
+export class SessionOrmEntity implements ISession {
+  @PrimaryColumn('varchar', { length: 255 })
+  id!: string;
+
+  @Column('text')
+  json!: string;
+
+  @Index()
+  @Column('bigint')
+  expiredAt!: number;
+
+  @DeleteDateColumn({ name: 'destroyed_at' })
+  destroyedAt?: Date;
+}