@api-client/core 0.18.25 → 0.18.26

package/build/src/modeling/templates/verticals/business-services/financial-services-domain.js

@@ -23,6 +23,7 @@
  * ```
  */
 import { DataDomain } from '../../../DataDomain.js';
+import { SemanticType } from '../../../Semantics.js';
 import { addIdField, addNameField, addDescriptionField, addEmailField, addFirstNameField, addLastNameField, addPhoneField, addCustomStatusField, addCreatedAtField, addUpdatedAtField, addCurrencyAmountField, } from '../../../helpers/Intelisense.js';
 function createDomain() {
     return new DataDomain({
@@ -50,72 +51,186 @@ export default function createFinancialServicesDomain(options = {}) {
     // Ensure the root data domain
     const domain = options.domain ?? createDomain();
     //
-    // 1. CUSTOMER MANAGEMENT NAMESPACE
+    // 1. USER & AUTHENTICATION NAMESPACE (Unified for customers and employees)
     //
-    const customerManagement = domain.addNamespace({
+    const userManagement = domain.addNamespace({
         info: {
-            name: 'CustomerManagement',
-            displayName: 'Customer Management',
-            description: 'Customer profiles, KYC, risk assessment, and segmentation',
+            name: 'User Management',
+            displayName: 'User & Authentication Management',
+            description: 'Unified user authentication, roles, and profile management for customers and employees',
         },
     });
-    // Customer Model
-    const customerModel = customerManagement.addModel({
+    // Authentication Model
+    const authModel = userManagement.addModel({
         info: {
-            name: 'Customers',
-            displayName: 'Customer Management',
-            description: 'Customer profiles and information',
+            name: 'Authentication',
+            displayName: 'Authentication & Access Control',
+            description: 'User authentication, sessions, and access control',
         },
     });
-    // Customer Entity
-    const customerEntity = customerModel.addEntity({
+    // Unified User Entity (replaces separate Customer and Employee entities)
+    const userEntity = authModel.addEntity({
         info: {
-            name: 'customer',
-            displayName: 'Customer',
-            description: 'Financial services customer with KYC and risk profile',
+            name: 'user',
+            displayName: 'User',
+            description: 'Unified user entity for both customers and employees with role-based access',
         },
+        semantics: [{ id: SemanticType.User }], // Mark as a user entity for automatic behaviors
     });
-    addIdField(customerEntity, { displayName: 'Customer ID', description: 'Unique identifier for the customer' });
-    addFirstNameField(customerEntity, { description: 'Customer first name' });
-    addLastNameField(customerEntity, { description: 'Customer last name' });
-    customerEntity.addProperty({
+    addIdField(userEntity, { displayName: 'User ID', description: 'Unique identifier for the user' });
+    // Authentication fields
+    userEntity.addProperty({
+        info: { name: 'username', displayName: 'Username', description: 'Unique username for login' },
+        type: 'string',
+        required: true,
+        unique: true,
+    });
+    userEntity.addProperty({
+        info: { name: 'password', displayName: 'Password', description: 'User password (hashed)' },
+        type: 'string',
+        required: true,
+        writeOnly: true,
+        semantics: [{ id: SemanticType.Password }], // Automatic password security behaviors
+    });
+    const emailProperty = addEmailField(userEntity, { description: 'User email address' });
+    emailProperty.required = true;
+    emailProperty.unique = true;
+    // Personal Information
+    addFirstNameField(userEntity, { description: 'User first name' });
+    addLastNameField(userEntity, { description: 'User last name' });
+    addPhoneField(userEntity, { description: 'User phone number' });
+    // User Type & Role (unified approach)
+    userEntity.addProperty({
+        info: { name: 'user_type', displayName: 'User Type', description: 'Type of user account' },
+        type: 'string',
+        required: true,
+        schema: {
+            enum: ['customer', 'employee', 'admin', 'system'],
+        },
+    });
+    userEntity.addProperty({
+        info: { name: 'role', displayName: 'User Role', description: 'User role defining permissions and access level' },
+        type: 'string',
+        required: true,
+        schema: {
+            enum: [
+                // Customer roles
+                'individual_customer',
+                'business_customer',
+                'premium_customer',
+                'private_banking_customer',
+                // Employee roles
+                'teller',
+                'loan_officer',
+                'relationship_manager',
+                'compliance_officer',
+                'branch_manager',
+                'investment_advisor',
+                'risk_analyst',
+                // Admin roles
+                'system_admin',
+                'security_admin',
+                'audit_admin',
+            ],
+        },
+    });
+    // Status and verification
+    addCustomStatusField(userEntity, ['active', 'inactive', 'suspended', 'pending_verification', 'locked'], {
+        displayName: 'User Status',
+        description: 'Current status of the user account',
+    });
+    userEntity.addProperty({
+        info: { name: 'email_verified', displayName: 'Email Verified', description: 'Whether user email is verified' },
+        type: 'boolean',
+        required: true,
+    });
+    userEntity.addProperty({
+        info: { name: 'last_login', displayName: 'Last Login', description: 'When user last logged in' },
+        type: 'datetime',
+    });
+    addCreatedAtField(userEntity, { description: 'When the user account was created' });
+    addUpdatedAtField(userEntity, { description: 'When the user account was last updated' });
+    // Session Entity for authentication management
+    const sessionEntity = authModel.addEntity({
+        info: {
+            name: 'user_session',
+            displayName: 'User Session',
+            description: 'Active user authentication sessions',
+        },
+    });
+    addIdField(sessionEntity, { displayName: 'Session ID', description: 'Unique session identifier' });
+    sessionEntity.addProperty({
+        info: { name: 'token', displayName: 'Session Token', description: 'Authentication token for the session' },
+        type: 'string',
+        required: true,
+        writeOnly: true,
+    });
+    sessionEntity.addProperty({
+        info: { name: 'expires_at', displayName: 'Expires At', description: 'When the session expires' },
+        type: 'datetime',
+        required: true,
+    });
+    sessionEntity.addProperty({
+        info: { name: 'ip_address', displayName: 'IP Address', description: 'IP address of the session' },
+        type: 'string',
+        semantics: [{ id: SemanticType.ClientIPAddress }],
+    });
+    addCreatedAtField(sessionEntity, { description: 'When the session was created' });
+    // User-Session Association
+    userEntity.addAssociation({ key: sessionEntity.key }, {
+        info: { name: 'sessions', displayName: 'User Sessions', description: 'Active sessions for this user' },
+        required: false,
+        multiple: true,
+    });
+    // Profile Model (for extended user information)
+    const profileModel = userManagement.addModel({
+        info: {
+            name: 'User Profiles',
+            displayName: 'User Profile Management',
+            description: 'Extended user profile information and preferences',
+        },
+    });
+    // Customer Profile Entity (for customer-specific information)
+    const customerProfileEntity = profileModel.addEntity({
+        info: {
+            name: 'customer_profile',
+            displayName: 'Customer Profile',
+            description: 'Additional profile information specific to customers',
+        },
+    });
+    addIdField(customerProfileEntity, { displayName: 'Profile ID', description: 'Unique profile identifier' });
+    customerProfileEntity.addProperty({
         info: { name: 'date_of_birth', displayName: 'Date of Birth', description: 'Customer date of birth' },
         type: 'date',
         required: true,
     });
-    customerEntity.addProperty({
+    customerProfileEntity.addProperty({
         info: { name: 'ssn', displayName: 'Social Security Number', description: 'Customer SSN for identification' },
         type: 'string',
         required: true,
-        writeOnly: true, // Sensitive data - write only
+        writeOnly: true,
     });
-    addEmailField(customerEntity, { description: 'Customer email address' });
-    addPhoneField(customerEntity, { description: 'Customer phone number' });
-    customerEntity.addProperty({
+    customerProfileEntity.addProperty({
         info: { name: 'address', displayName: 'Address', description: 'Customer residential address' },
         type: 'string',
         required: true,
     });
-    customerEntity.addProperty({
+    customerProfileEntity.addProperty({
         info: { name: 'city', displayName: 'City', description: 'Customer city' },
         type: 'string',
         required: true,
     });
-    customerEntity.addProperty({
+    customerProfileEntity.addProperty({
         info: { name: 'state', displayName: 'State', description: 'Customer state' },
         type: 'string',
         required: true,
     });
-    customerEntity.addProperty({
+    customerProfileEntity.addProperty({
         info: { name: 'zip_code', displayName: 'ZIP Code', description: 'Customer ZIP code' },
         type: 'string',
         required: true,
     });
-    addCustomStatusField(customerEntity, ['active', 'inactive', 'suspended', 'pending_verification'], {
-        displayName: 'Customer Status',
-        description: 'Current status of the customer account',
-    });
-    customerEntity.addProperty({
+    customerProfileEntity.addProperty({
         info: { name: 'customer_type', displayName: 'Customer Type', description: 'Type of customer account' },
         type: 'string',
         required: true,
@@ -123,12 +238,79 @@ export default function createFinancialServicesDomain(options = {}) {
             enum: ['individual', 'business', 'trust', 'partnership'],
         },
     });
-    addCreatedAtField(customerEntity, { description: 'When the customer account was created' });
-    addUpdatedAtField(customerEntity, { description: 'When the customer account was last updated' });
-    // KYC Entity
-    const kycEntity = customerModel.addEntity({
+    addCreatedAtField(customerProfileEntity, { description: 'When the customer profile was created' });
+    addUpdatedAtField(customerProfileEntity, { description: 'When the customer profile was last updated' });
+    // User-CustomerProfile Association (one-to-one for customers)
+    userEntity.addAssociation({ key: customerProfileEntity.key }, {
+        info: {
+            name: 'customer_profile',
+            displayName: 'Customer Profile',
+            description: 'Extended customer profile information',
+        },
+        required: false, // Only for customers, not employees
+        multiple: false,
+    });
+    // Employee Profile Entity (for employee-specific information)
+    const employeeProfileEntity = profileModel.addEntity({
+        info: {
+            name: 'employee_profile',
+            displayName: 'Employee Profile',
+            description: 'Additional profile information specific to employees',
+        },
+    });
+    addIdField(employeeProfileEntity, {
+        displayName: 'Employee Profile ID',
+        description: 'Unique employee profile identifier',
+    });
+    employeeProfileEntity.addProperty({
+        info: { name: 'employee_id', displayName: 'Employee ID', description: 'Company employee identifier' },
+        type: 'string',
+        required: true,
+        unique: true,
+    });
+    employeeProfileEntity.addProperty({
+        info: { name: 'department', displayName: 'Department', description: 'Employee department' },
+        type: 'string',
+        required: true,
+        schema: {
+            enum: [
+                'retail_banking',
+                'commercial_banking',
+                'investment_services',
+                'risk_management',
+                'compliance',
+                'operations',
+                'technology',
+                'human_resources',
+                'legal',
+            ],
+        },
+    });
+    employeeProfileEntity.addProperty({
+        info: { name: 'hire_date', displayName: 'Hire Date', description: 'Employee hire date' },
+        type: 'date',
+        required: true,
+    });
+    employeeProfileEntity.addProperty({
+        info: { name: 'manager_id', displayName: 'Manager ID', description: 'Employee manager identifier' },
+        type: 'string',
+    });
+    addCreatedAtField(employeeProfileEntity, { description: 'When the employee profile was created' });
+    addUpdatedAtField(employeeProfileEntity, { description: 'When the employee profile was last updated' });
+    // User-EmployeeProfile Association (one-to-one for employees)
+    userEntity.addAssociation({ key: employeeProfileEntity.key }, {
+        info: {
+            name: 'employee_profile',
+            displayName: 'Employee Profile',
+            description: 'Extended employee profile information',
+        },
+        required: false, // Only for employees, not customers
+        multiple: false,
+    });
+    // KYC Entity (enhanced for the unified approach)
+    const kycEntity = profileModel.addEntity({
         info: {
-            name: 'kyc',
+            name: 'kyc_record',
             displayName: 'KYC Record',
             description: 'Know Your Customer verification and documentation',
         },
@@ -156,14 +338,15 @@ export default function createFinancialServicesDomain(options = {}) {
         required: true,
     });
     addCreatedAtField(kycEntity, { description: 'When the KYC record was created' });
-    // KYC-Customer Association (One-to-One)
-    kycEntity.addAssociation({ key: customerEntity.key }, {
-        info: { name: 'customer', displayName: 'Customer', description: 'Customer for this KYC record' },
+    addUpdatedAtField(kycEntity, { description: 'When the KYC record was last updated' });
+    // KYC-User Association (One-to-One)
+    kycEntity.addAssociation({ key: userEntity.key }, {
+        info: { name: 'user', displayName: 'User', description: 'User for this KYC record' },
         required: true,
         multiple: false,
     });
     // Risk Profile Entity
-    const riskProfileEntity = customerModel.addEntity({
+    const riskProfileEntity = profileModel.addEntity({
         info: {
             name: 'risk_profile',
             displayName: 'Risk Profile',
@@ -194,9 +377,10 @@ export default function createFinancialServicesDomain(options = {}) {
     });
     addDescriptionField(riskProfileEntity, { description: 'Risk assessment notes and factors' });
     addCreatedAtField(riskProfileEntity, { description: 'When the risk profile was created' });
-    // RiskProfile-Customer Association (One-to-One)
-    riskProfileEntity.addAssociation({ key: customerEntity.key }, {
-        info: { name: 'customer', displayName: 'Customer', description: 'Customer for this risk profile' },
+    addUpdatedAtField(riskProfileEntity, { description: 'When the risk profile was last updated' });
+    // RiskProfile-User Association (One-to-One)
+    riskProfileEntity.addAssociation({ key: userEntity.key }, {
+        info: { name: 'user', displayName: 'User', description: 'User for this risk profile' },
         required: true,
         multiple: false,
     });
@@ -258,9 +442,9 @@ export default function createFinancialServicesDomain(options = {}) {
     });
     addCreatedAtField(bankAccountEntity, { description: 'When the account was created' });
     addUpdatedAtField(bankAccountEntity, { description: 'When the account was last updated' });
-    // BankAccount-Customer Association (Many-to-One)
-    bankAccountEntity.addAssociation({ key: customerEntity.key }, {
-        info: { name: 'customer', displayName: 'Account Holder', description: 'Customer who owns this account' },
+    // BankAccount-User Association (Many-to-One)
+    bankAccountEntity.addAssociation({ key: userEntity.key }, {
+        info: { name: 'user', displayName: 'Account Holder', description: 'User who owns this account' },
         required: true,
         multiple: false,
     });
@@ -301,12 +485,12 @@ export default function createFinancialServicesDomain(options = {}) {
         description: 'Current status of the investment account',
     });
     addCreatedAtField(investmentAccountEntity, { description: 'When the investment account was created' });
-    // InvestmentAccount-Customer Association (Many-to-One)
-    investmentAccountEntity.addAssociation({ key: customerEntity.key }, {
+    // InvestmentAccount-User Association (Many-to-One)
+    investmentAccountEntity.addAssociation({ key: userEntity.key }, {
         info: {
-            name: 'customer',
+            name: 'user',
             displayName: 'Account Holder',
-            description: 'Customer who owns this investment account',
+            description: 'User who owns this investment account',
         },
         required: true,
         multiple: false,
@@ -349,9 +533,9 @@ export default function createFinancialServicesDomain(options = {}) {
         description: 'Current status of the credit card',
     });
     addCreatedAtField(creditCardEntity, { description: 'When the credit card was created' });
-    // CreditCard-Customer Association (Many-to-One)
-    creditCardEntity.addAssociation({ key: customerEntity.key }, {
-        info: { name: 'customer', displayName: 'Cardholder', description: 'Customer who owns this credit card' },
+    // CreditCard-User Association (Many-to-One)
+    creditCardEntity.addAssociation({ key: userEntity.key }, {
+        info: { name: 'user', displayName: 'Cardholder', description: 'User who owns this credit card' },
         required: true,
         multiple: false,
     });
@@ -360,7 +544,7 @@ export default function createFinancialServicesDomain(options = {}) {
     //
     const transactionProcessing = domain.addNamespace({
         info: {
-            name: 'TransactionProcessing',
+            name: 'Transaction Processing',
             displayName: 'Transaction Processing',
             description: 'Payments, transfers, deposits, and withdrawals',
         },
@@ -421,9 +605,9 @@ export default function createFinancialServicesDomain(options = {}) {
         type: 'string',
     });
     addCreatedAtField(transactionEntity, { description: 'When the transaction was created' });
-    // Transaction-Customer Association (Many-to-One)
-    transactionEntity.addAssociation({ key: customerEntity.key }, {
-        info: { name: 'customer', displayName: 'Customer', description: 'Customer who initiated the transaction' },
+    // Transaction-User Association (Many-to-One)
+    transactionEntity.addAssociation({ key: userEntity.key }, {
+        info: { name: 'user', displayName: 'User', description: 'User who initiated the transaction' },
         required: true,
         multiple: false,
     });
@@ -472,7 +656,7 @@ export default function createFinancialServicesDomain(options = {}) {
     //
     const investmentPortfolio = domain.addNamespace({
         info: {
-            name: 'InvestmentPortfolio',
+            name: 'Investment Portfolio',
             displayName: 'Investment Portfolio',
             description: 'Assets, positions, and performance tracking',
         },
@@ -596,7 +780,7 @@ export default function createFinancialServicesDomain(options = {}) {
     //
     const complianceReporting = domain.addNamespace({
         info: {
-            name: 'ComplianceReporting',
+            name: 'Compliance Reporting',
             displayName: 'Compliance & Reporting',
             description: 'Regulatory reporting and audit trails',
         },
@@ -641,6 +825,7 @@ export default function createFinancialServicesDomain(options = {}) {
     auditTrailEntity.addProperty({
         info: { name: 'ip_address', displayName: 'IP Address', description: 'IP address of the user' },
         type: 'string',
+        semantics: [{ id: SemanticType.ClientIPAddress }],
     });
     addDescriptionField(auditTrailEntity, { description: 'Additional details about the action' });
     addCreatedAtField(auditTrailEntity, {
@@ -733,9 +918,9 @@ export default function createFinancialServicesDomain(options = {}) {
         required: false,
         multiple: false,
     });
-    // FraudAlert-Customer Association (Many-to-One)
-    fraudAlertEntity.addAssociation({ key: customerEntity.key }, {
-        info: { name: 'customer', displayName: 'Customer', description: 'Customer associated with the alert' },
+    // FraudAlert-User Association (Many-to-One)
+    fraudAlertEntity.addAssociation({ key: userEntity.key }, {
+        info: { name: 'user', displayName: 'User', description: 'User associated with the alert' },
         required: true,
         multiple: false,
     });