Shared Models

Ecosistema completo para organización y gestión de contenido con interfaces espaciales

Librería Shared Models (Core) - Descripción

Propósito: Proporcionar modelos, interfaces y tipos compartidos para todo el workspace de GoGrab, garantizando consistencia y reutilización entre todas las librerías y aplicaciones.

Estado Actual

Arquitectura de Modelos Compartidos

La librería implementa un sistema de modelos centralizados que sirve como fuente única de verdad para todos los tipos de datos utilizados en el sistema multitenancy.

Principios Arquitectónicos

Organización por Dominios

Tenant Domain

Authentication Domain

RBAC Domain (Role-Based Access Control)

UI Domain

API Domain

API Pública

Tenant Models

export interface Context {
  tenantId: string;
  tenantName: string;
  apiBaseUrl: string;
  locale: string;
  timezone: string;
  permissions: Permissions;
  configuration: Config;
  features: Features;
}

export interface Config {
  modules: Record<string, ModuleConfig>;
  ui: UiConfig;
  limits: ResourceLimits;
}

export interface Permissions {
  permissions: string[];
  modules: Record<string, ModulePermissions>;
  resources: Record<string, ResourcePermissions>;
}

Authentication Models

export interface UserProfile {
  id: string;
  tenantId: string;
  email: string;
  username: string;
  firstName: string;
  lastName: string;
  avatar?: string;
  roles: Role[];
  permissions: Permission[];
  preferences: UserPreferences;
  isActive: boolean;
  lastLogin?: Date;
  emailVerified: boolean;
  twoFactorEnabled: boolean;
  createdAt: Date;
  updatedAt: Date;
}

export interface LoginCredentials {
  email: string;
  password: string;
}

export interface LoginResult {
  accessToken: string;
  refreshToken: string;
  user: UserProfile;
  availableTenants: ContextInfo[];
}

RBAC Models

export interface Role {
  id: string;
  tenantId: string;
  name: string;
  description: string;
  permissions: Permission[];
  isSystemRole: boolean;
  isActive: boolean;
  createdAt: Date;
  updatedAt: Date;
}

export interface Permission {
  id: string;
  tenantId: string;
  name: string;
  resource: string;
  action: string;
  scope: PermissionScope;
  conditions?: PermissionCondition[];
}

export type PermissionScope = 'own' | 'team' | 'department' | 'all';

Estructura del Paquete

src/lib/
├── tenant/
│   ├── context.ts                 # Context interface
│   ├── config.ts                  # Config, UiConfig, ResourceLimits
│   ├── permissions.ts             # Permissions, ModulePermissions
│   ├── features.ts                # Features interface
│   ├── context-info.ts            # ContextInfo para login
│   └── index.ts                   # Exportaciones tenant
├── auth/
│   ├── user-profile.ts            # UserProfile interface
│   ├── auth-state.ts              # AuthState union types
│   ├── login-credentials.ts       # LoginCredentials interface
│   ├── login-result.ts            # LoginResult interface
│   ├── selection-result.ts        # SelectionResult interface
│   ├── auth-errors.ts             # AuthError types
│   └── index.ts                   # Exportaciones auth
├── rbac/
│   ├── role.ts                    # Role interface
│   ├── permission.ts              # Permission interface
│   ├── permission-scope.ts        # PermissionScope types
│   ├── permission-condition.ts    # PermissionCondition interface
│   ├── resource-permissions.ts    # ResourcePermissions interface
│   └── index.ts                   # Exportaciones rbac
├── ui/
│   ├── branding-config.ts         # BrandingConfig interface
│   ├── module-config.ts           # ModuleConfig interface
│   ├── user-preferences.ts        # UserPreferences interface
│   ├── theme-config.ts            # ThemeConfig interface
│   ├── ui-config.ts               # UiConfig interface
│   └── index.ts                   # Exportaciones ui
├── api/
│   ├── api-response.ts            # ApiResponse<T> generic
│   ├── pagination.ts              # PaginationRequest, PaginationResponse
│   ├── error-response.ts          # ErrorResponse interface
│   ├── request-metadata.ts        # RequestMetadata interface
│   ├── filter-criteria.ts         # FilterCriteria interface
│   └── index.ts                   # Exportaciones api
├── common/
│   ├── base-entity.ts             # BaseEntity interface
│   ├── audit-fields.ts            # AuditFields interface
│   ├── date-range.ts              # DateRange interface
│   ├── key-value.ts               # KeyValue<T> interface
│   └── index.ts                   # Exportaciones common
└── index.ts                       # Exportación principal

Casos de Uso

1. Librería Security

import { Context, UserProfile, LoginCredentials, AuthState } from '@libs-core/shared-models';

@Injectable()
export class AuthService {
  currentUser = signal<UserProfile | null>(null);
  currentContext = signal<Context | null>(null);

  async login(credentials: LoginCredentials): Promise<void> {
    // ...
  }
}

2. Librería Data Access

import { UserProfile, ApiResponse, PaginationRequest } from '@libs-core/shared-models';

@Injectable()
export class UserService {
  getUsers(pagination: PaginationRequest): Observable<ApiResponse<UserProfile[]>> {
    return this.http.get<ApiResponse<UserProfile[]>>('/api/users', { params: pagination });
  }
}

3. Librería Module Base

import { Context, Permission, ModuleConfig } from '@libs-core/shared-models';

export class BaseModule {
  constructor(private context: Context) {}

  hasPermission(permission: Permission): boolean {
    // ...
  }
}

Ventajas Arquitectónicas

Consistencia

Performance

Mantenibilidad

Métricas de Calidad

Tipado

Documentación

Testing

Comandos de Desarrollo

# Crear la librería
nx generate @nx/js:library shared-models \
  --directory=libs/core \
  --importPath=@libs-core/shared-models \
  --strict

# Validar tipos
nx run shared-models:type-check

# Generar documentación
nx run shared-models:docs

# Publicar (interno)
nx run shared-models:build

Roadmap

Fase 1: Modelos Base (Semana 1)

Fase 2: Modelos UI y API (Semana 2)

Fase 3: Validación y Testing (Semana 3)

Fase 4: Integración (Semana 4)

Esta librería se convierte en la base fundamental de todo el sistema GoGrab, garantizando consistencia, reutilización y mantenibilidad en todo el workspace.