@api-client/core 0.18.25 → 0.18.27

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

@@ -24,6 +24,7 @@
  */
 
 import { DataDomain } from '../../../DataDomain.js'
+import { SemanticType } from '../../../Semantics.js'
 import {
   addIdField,
   addNameField,
@@ -68,85 +69,220 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   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' })
+  addIdField(userEntity, { displayName: 'User ID', description: 'Unique identifier for the user' })
 
-  addFirstNameField(customerEntity, { description: 'Customer first name' })
-  addLastNameField(customerEntity, { description: 'Customer last name' })
+  // 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',
+      ],
+    },
+    semantics: [{ id: SemanticType.UserRole }],
+  })
+
+  // 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,
+  })
 
-  customerEntity.addProperty({
+  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,
@@ -155,13 +291,95 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
     },
   })
 
-  addCreatedAtField(customerEntity, { description: 'When the customer account was created' })
-  addUpdatedAtField(customerEntity, { description: 'When the customer account was last updated' })
+  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
-  const kycEntity = customerModel.addEntity({
+  // 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',
     },
@@ -195,19 +413,20 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   })
 
   addCreatedAtField(kycEntity, { description: 'When the KYC record was created' })
+  addUpdatedAtField(kycEntity, { description: 'When the KYC record was last updated' })
 
-  // KYC-Customer Association (One-to-One)
+  // KYC-User Association (One-to-One)
   kycEntity.addAssociation(
-    { key: customerEntity.key },
+    { key: userEntity.key },
     {
-      info: { name: 'customer', displayName: 'Customer', description: 'Customer for this KYC record' },
+      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',
@@ -244,12 +463,13 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   addDescriptionField(riskProfileEntity, { description: 'Risk assessment notes and factors' })
 
   addCreatedAtField(riskProfileEntity, { description: 'When the risk profile was created' })
+  addUpdatedAtField(riskProfileEntity, { description: 'When the risk profile was last updated' })
 
-  // RiskProfile-Customer Association (One-to-One)
+  // RiskProfile-User Association (One-to-One)
   riskProfileEntity.addAssociation(
-    { key: customerEntity.key },
+    { key: userEntity.key },
     {
-      info: { name: 'customer', displayName: 'Customer', description: 'Customer for this risk profile' },
+      info: { name: 'user', displayName: 'User', description: 'User for this risk profile' },
       required: true,
       multiple: false,
     }
@@ -324,11 +544,11 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   addCreatedAtField(bankAccountEntity, { description: 'When the account was created' })
   addUpdatedAtField(bankAccountEntity, { description: 'When the account was last updated' })
 
-  // BankAccount-Customer Association (Many-to-One)
+  // BankAccount-User Association (Many-to-One)
   bankAccountEntity.addAssociation(
-    { key: customerEntity.key },
+    { key: userEntity.key },
     {
-      info: { name: 'customer', displayName: 'Account Holder', description: 'Customer who owns this account' },
+      info: { name: 'user', displayName: 'Account Holder', description: 'User who owns this account' },
       required: true,
       multiple: false,
     }
@@ -379,14 +599,14 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
 
   addCreatedAtField(investmentAccountEntity, { description: 'When the investment account was created' })
 
-  // InvestmentAccount-Customer Association (Many-to-One)
+  // InvestmentAccount-User Association (Many-to-One)
   investmentAccountEntity.addAssociation(
-    { key: customerEntity.key },
+    { 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,
@@ -440,11 +660,11 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
 
   addCreatedAtField(creditCardEntity, { description: 'When the credit card was created' })
 
-  // CreditCard-Customer Association (Many-to-One)
+  // CreditCard-User Association (Many-to-One)
   creditCardEntity.addAssociation(
-    { key: customerEntity.key },
+    { key: userEntity.key },
     {
-      info: { name: 'customer', displayName: 'Cardholder', description: 'Customer who owns this credit card' },
+      info: { name: 'user', displayName: 'Cardholder', description: 'User who owns this credit card' },
       required: true,
       multiple: false,
     }
@@ -455,7 +675,7 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   //
   const transactionProcessing = domain.addNamespace({
     info: {
-      name: 'TransactionProcessing',
+      name: 'Transaction Processing',
       displayName: 'Transaction Processing',
       description: 'Payments, transfers, deposits, and withdrawals',
     },
@@ -528,11 +748,11 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
 
   addCreatedAtField(transactionEntity, { description: 'When the transaction was created' })
 
-  // Transaction-Customer Association (Many-to-One)
+  // Transaction-User Association (Many-to-One)
   transactionEntity.addAssociation(
-    { key: customerEntity.key },
+    { key: userEntity.key },
     {
-      info: { name: 'customer', displayName: 'Customer', description: 'Customer who initiated the transaction' },
+      info: { name: 'user', displayName: 'User', description: 'User who initiated the transaction' },
       required: true,
       multiple: false,
     }
@@ -601,7 +821,7 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   //
   const investmentPortfolio = domain.addNamespace({
     info: {
-      name: 'InvestmentPortfolio',
+      name: 'Investment Portfolio',
       displayName: 'Investment Portfolio',
       description: 'Assets, positions, and performance tracking',
     },
@@ -760,7 +980,7 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   //
   const complianceReporting = domain.addNamespace({
     info: {
-      name: 'ComplianceReporting',
+      name: 'Compliance Reporting',
       displayName: 'Compliance & Reporting',
       description: 'Regulatory reporting and audit trails',
     },
@@ -813,6 +1033,7 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
   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' })
@@ -929,11 +1150,11 @@ export default function createFinancialServicesDomain(options: CreateTemplateOpt
     }
   )
 
-  // FraudAlert-Customer Association (Many-to-One)
+  // FraudAlert-User Association (Many-to-One)
   fraudAlertEntity.addAssociation(
-    { key: customerEntity.key },
+    { key: userEntity.key },
     {
-      info: { name: 'customer', displayName: 'Customer', description: 'Customer associated with the alert' },
+      info: { name: 'user', displayName: 'User', description: 'User associated with the alert' },
       required: true,
       multiple: false,
     }

package/src/modeling/templates/verticals/technology-media/blog-domain.ts

@@ -454,10 +454,18 @@ export default function createBlogDomain(options: CreateTemplateOptions = {}): D
   //   // semantics: [{ id: SemanticType.SocialMediaLinks }],
   // })
 
-  addCustomStatusField(userEntity, ['subscriber', 'author', 'editor', 'admin', 'super_admin'], {
-    name: 'role',
-    displayName: 'User Role',
-    description: 'User role for permission management',
+  userEntity.addProperty({
+    info: { name: 'role', displayName: 'User Role', description: 'User role for permission management' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['subscriber', 'author', 'editor', 'admin', 'super_admin'],
+      defaultValue: {
+        type: 'literal',
+        value: 'subscriber',
+      },
+    },
+    semantics: [{ id: SemanticType.UserRole }],
   })
 
   addCustomStatusField(userEntity, ['active', 'inactive', 'suspended', 'pending_verification'], {
@@ -634,11 +642,11 @@ export default function createBlogDomain(options: CreateTemplateOptions = {}): D
     semantics: [createURLSemantic()],
   })
 
-  // pageViewEntity.addProperty({
-  //   info: { name: 'ip_address', displayName: 'IP Address', description: 'Visitor IP address' },
-  //   type: 'string',
-  //   semantics: [{ id: SemanticType.IPAddress }],
-  // })
+  pageViewEntity.addProperty({
+    info: { name: 'ip_address', displayName: 'IP Address', description: 'Visitor IP address' },
+    type: 'string',
+    semantics: [{ id: SemanticType.ClientIPAddress }],
+  })
 
   pageViewEntity.addProperty({
     info: { name: 'user_agent', displayName: 'User Agent', description: 'Browser user agent string' },

package/src/modeling/templates/verticals/technology-media/iot-smart-home-domain.ts

@@ -41,6 +41,7 @@ import {
   addCreatedAtField,
   addUpdatedAtField,
 } from '../../../helpers/Intelisense.js'
+import { SemanticType } from '../../../Semantics.js'
 import type { CreateTemplateOptions } from '../../types.js'
 
 function createDomain(): DataDomain {
@@ -156,6 +157,7 @@ export default function createIoTSmartHomeDomain(options: CreateTemplateOptions
     info: { name: 'ip_address', displayName: 'IP Address', description: 'Device IP address' },
     type: 'string',
     required: false,
+    semantics: [{ id: SemanticType.ClientIPAddress }],
   })
 
   deviceEntity.addProperty({

package/src/modeling/validation/postgresql.ts

@@ -41,7 +41,6 @@ export const ReservedKeywords = new Set([
   'COMMIT',
   'ROLLBACK',
   'SAVEPOINT',
-  'TRANSACTION',
   'BEGIN',
   'END',
   'CASE',