@api-client/core 0.18.56 → 0.18.57

package/src/modeling/templates/readme.md

@@ -1,260 +0,0 @@
-# Domain Templates
-
-The domain templates allow creating or updating existing data domains from a template. Templates follow the Domain-Driven Design (DDD) principles and provide pre-built business domain structures that users can instantiate or extend.
-
-## Organization by Industry Verticals
-
-Templates are organized by industry verticals to provide better categorization and discovery:
-
-- **Business Services**: E-commerce, Financial Services, Legal Services
-- **Healthcare & Life Sciences**: Healthcare, Pharmaceutical, Research  
-- **Education & Training**: Education, Corporate Training, Certification
-- **Real Estate & Construction**: Real Estate, Construction, Property Management
-- **Manufacturing & Logistics**: Manufacturing, Supply Chain, Distribution
-- **Technology & Media**: Gaming, IoT, Content Management, Social Media
-- **Public Sector**: Government, Non-Profit, Healthcare
-
-See `verticals/README.md` for detailed information about the vertical organization.
-
-## Template Structure
-
-Each template is a TypeScript file that exports a default function conforming to the template signature. Templates create comprehensive data domains with proper namespace organization, entity relationships, and semantic annotations.
-
-### Required Function Signature
-
-```typescript
-import type { CreateTemplateOptions } from './types.js'
-import { DataDomain } from '../DataDomain.js'
-
-export default function createMyDomain(options: CreateTemplateOptions = {}): DataDomain {
-  // Template implementation
-}
-```
-
-### Template Implementation Pattern
-
-```typescript
-/**
- * Template Documentation Header
- * 
- * Provide comprehensive documentation explaining:
- * - What business domain this template models
- * - Key entities and relationships included
- * - Semantic annotations and business rules applied
- * - Example usage scenarios
- */
-
-import { DataDomain } from '../DataDomain.js'
-import { SemanticType } from '../Semantics.js'
-import {
-  addIdField,
-  addNameField,
-  addEmailField,
-  // Import other helper functions as needed
-} from '../helpers/Intelisense.js'
-import type { CreateTemplateOptions } from './types.js'
-
-function createDomain(): DataDomain {
-  return new DataDomain({
-    info: {
-      name: 'My Business Domain',
-      displayName: 'My Business Domain',
-      description: 'Clear description of what this domain models',
-    },
-  })
-}
-
-export default function createMyDomain(options: CreateTemplateOptions = {}): DataDomain {
-  // Use existing domain if provided, otherwise create new one
-  const domain = options.domain ?? createDomain()
-  
-  // Create namespaces following business capabilities
-  const coreNamespace = domain.addNamespace({ 
-    info: { name: 'CoreManagement' } 
-  })
-  
-  // Add models to organize related entities
-  const entityModel = coreNamespace.addModel({ 
-    info: { name: 'CoreEntities' } 
-  })
-  
-  // Create entities with proper semantic annotations
-  const mainEntity = entityModel.addEntity({ 
-    info: { name: 'MainEntity' },
-    semantics: [{ type: SemanticType.User }] // If applicable
-  })
-  
-  // Add properties using helper functions for consistency
-  addIdField(mainEntity)
-  addNameField(mainEntity)
-  addEmailField(mainEntity)
-  
-  // Add custom properties with proper semantics
-  mainEntity.addProperty({
-    info: { name: 'customField' },
-    type: 'string',
-    required: false,
-    semantics: [/* appropriate semantics */]
-  })
-  
-  // Create associations between entities
-  // (Add more entities and relationships as needed)
-  
-  return domain
-}
-```
-
-## Adding a Template
-
-### 1. Create the Template File
-
-Create a new file `[domain-name]-domain.ts` in `src/modeling/templates/` following the naming convention:
-
-- Use kebab-case for file names
-- End with `-domain.ts`
-- Examples: `healthcare-domain.ts`, `financial-services-domain.ts`
-
-### 2. Follow Modeling Guidelines
-
-Templates must adhere to the modeling instructions in `.github/instructions/modeling.instructions.md`:
-
-- **Business-First Approach**: Model business concepts, not technical concerns
-- **Proper Hierarchy**: DataDomain → DomainNamespace → DomainModel → DomainEntity → DomainProperty
-- **Semantic Annotations**: Use `SemanticType` for passwords, emails, timestamps, etc.
-- **Security**: Mark sensitive properties as `writeOnly`, validate all inputs
-- **Database Compliance**: Follow PostgreSQL naming conventions (snake_case conversion)
-
-### 3. Required Imports
-
-Include these essential imports:
-
-```typescript
-import { DataDomain } from '../DataDomain.js'
-import { SemanticType } from '../Semantics.js'
-import type { CreateTemplateOptions } from './types.js'
-
-// Import semantic definition helpers as needed
-import { createCalculatedSemantic } from '../definitions/Calculated.js'
-import { createCurrencySemantic } from '../definitions/Currency.js'
-
-// Import property helper functions for consistency
-import {
-  addIdField,
-  addNameField,
-  addEmailField,
-  addPasswordField,
-  addCreatedAtField,
-  addUpdatedAtField,
-  // ... other helpers as needed
-} from '../helpers/Intelisense.js'
-```
-
-### 4. Handle Template Options
-
-Always support the `CreateTemplateOptions` interface:
-
-```typescript
-export default function createMyDomain(options: CreateTemplateOptions = {}): DataDomain {
-  // Use provided domain or create new one
-  const domain = options.domain ?? createDomain()
-  
-  // If domain is provided, you're extending an existing domain
-  // If not provided, you're creating a new domain
-  
-  return domain
-}
-```
-
-## Registering Templates
-
-### 1. Add to Generation Script
-
-Edit `scripts/generate-template-metadata.js` and add your template to the registry:
-
-```javascript
-// Import your template function
-import createMyDomain from '../build/src/modeling/templates/my-domain.js'
-
-// Add to templates array
-const TEMPLATE_CONFIGS = [
-  {
-    id: 'my-business-domain',
-    name: 'My Business Domain',
-    description: 'Brief description for UI display',
-    version: '1.0.0',
-    author: 'API Now! Core Team',
-    tags: ['business', 'industry-specific'], // For categorization
-    createdAt: '2025-01-01T00:00:00.000Z',
-    updatedAt: '2025-01-01T00:00:00.000Z',
-    createDomainFn: createMyDomain,
-  },
-  // ... other templates
-]
-```
-
-### 2. Template Metadata
-
-The generation script will create metadata including:
-
-- Template structure analysis (namespaces, models, entities)
-- Property counts and types
-- Association mappings
-- Semantic annotation usage
-- UI presentation information
-
-## Generating Metadata
-
-Each template needs to be processed to generate metadata files. These metadata are used to generate the templates view in the UI.
-
-**If you won't generate metadata, the template won't get registered by the UI.**
-
-### 1. Build the Project First
-
-```sh
-npm run build
-```
-
-### 2. Run the Metadata Generation Script
-
-```sh
-node scripts/generate-template-metadata.js
-```
-
-### 3. Rebuild to Include New Metadata
-
-```sh
-npm run build
-```
-
-All metadata are generated under `src/modeling/templates/meta` directory as JSON files.
-
-## Best Practices
-
-### Domain Design
-
-1. **Business Alignment**: Model actual business processes and entities
-2. **Clear Naming**: Use business-meaningful names, not technical jargon
-3. **Proper Grouping**: Organize entities into logical namespaces and models
-4. **Semantic Richness**: Apply appropriate semantic annotations for security and behavior
-
-### Code Quality
-
-1. **Documentation**: Include comprehensive JSDoc comments explaining the business purpose
-2. **Type Safety**: Use TypeScript interfaces and proper type annotations
-3. **Error Handling**: Validate inputs and provide clear error messages
-4. **Consistency**: Use helper functions from `helpers/Intelisense.js` for common patterns
-
-### Security
-
-1. **Sensitive Data**: Mark passwords and sensitive fields as `writeOnly`
-2. **Validation**: Validate all user inputs and model structures
-3. **Access Control**: Consider data access patterns in your domain design
-
-## Example Templates
-
-Refer to existing templates for comprehensive examples:
-
-- `ecommerce-domain.ts` - E-commerce platform with users, products, orders
-- `blog-domain.ts` - Content management with publishing workflow
-
-These demonstrate proper structure, semantic usage, and business modeling patterns.

package/src/modeling/templates/template-registry.ts

@@ -1,140 +0,0 @@
-import type { DomainTemplate } from './types.js'
-import {
-  getAllTemplates,
-  getTemplate,
-  getTemplatesByTag,
-  getTemplatesByCategory,
-  searchTemplates,
-  getTemplateStats,
-} from './meta/index.js'
-
-/**
- * Registry of all available domain templates with their metadata.
- * This provides a central location for UI components to discover and present templates.
- *
- * The templates are pre-processed at build time using the generate-template-metadata.js script
- * to avoid loading and processing all templates on the client side.
- */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class TemplateRegistry {
-  /**
-   * Gets all available templates
-   */
-  static getAllTemplates(): DomainTemplate[] {
-    return getAllTemplates()
-  }
-
-  /**
-   * Gets a template by its ID
-   */
-  static getTemplate(id: string): DomainTemplate | undefined {
-    return getTemplate(id)
-  }
-
-  /**
-   * Gets templates filtered by tags
-   */
-  static getTemplatesByTag(tag: string): DomainTemplate[] {
-    return getTemplatesByTag(tag)
-  }
-
-  /**
-   * Gets templates filtered by category (based on tags)
-   */
-  static getTemplatesByCategory(category: 'business' | 'content' | 'social' | 'technical'): DomainTemplate[] {
-    return getTemplatesByCategory(category)
-  }
-
-  /**
-   * Gets templates filtered by industry vertical
-   */
-  static getTemplatesByVertical(vertical: string): DomainTemplate[] {
-    // This would need to be implemented in the meta/index.js
-    return getAllTemplates().filter((template) =>
-      template.tags?.some((tag) => tag.toLowerCase().includes(vertical.toLowerCase()))
-    )
-  }
-
-  /**
-   * Gets all available industry verticals
-   */
-  static getIndustryVerticals(): {
-    id: string
-    name: string
-    description: string
-    subcategories: string[]
-    templateCount: number
-  }[] {
-    return [
-      {
-        id: 'business-services',
-        name: 'Business Services',
-        description: 'E-commerce, Financial Services, Legal Services',
-        subcategories: ['E-commerce', 'Financial Services', 'Legal Services'],
-        templateCount: 4,
-      },
-      {
-        id: 'healthcare-life-sciences',
-        name: 'Healthcare & Life Sciences',
-        description: 'Healthcare, Pharmaceutical, Research',
-        subcategories: ['Healthcare', 'Pharmaceutical', 'Research'],
-        templateCount: 1,
-      },
-      {
-        id: 'education-training',
-        name: 'Education & Training',
-        description: 'Education, Corporate Training, Certification',
-        subcategories: ['Education', 'Corporate Training', 'Certification'],
-        templateCount: 1,
-      },
-      {
-        id: 'real-estate-construction',
-        name: 'Real Estate & Construction',
-        description: 'Real Estate, Construction, Property Management',
-        subcategories: ['Real Estate', 'Construction', 'Property Management'],
-        templateCount: 1,
-      },
-      {
-        id: 'manufacturing-logistics',
-        name: 'Manufacturing & Logistics',
-        description: 'Manufacturing, Supply Chain, Distribution',
-        subcategories: ['Manufacturing', 'Supply Chain', 'Distribution'],
-        templateCount: 1,
-      },
-      {
-        id: 'technology-media',
-        name: 'Technology & Media',
-        description: 'Gaming, IoT, Content Management, Social Media',
-        subcategories: ['Gaming', 'IoT', 'Content Management', 'Social Media'],
-        templateCount: 3,
-      },
-      {
-        id: 'public-sector',
-        name: 'Public Sector',
-        description: 'Government, Non-Profit, Healthcare',
-        subcategories: ['Government', 'Non-Profit', 'Healthcare'],
-        templateCount: 1,
-      },
-    ]
-  }
-
-  /**
-   * Searches templates by name or description
-   */
-  static searchTemplates(query: string): DomainTemplate[] {
-    return searchTemplates(query)
-  }
-
-  /**
-   * Gets template statistics for analytics
-   */
-  static getTemplateStats(): {
-    totalTemplates: number
-    totalEntities: number
-    totalProperties: number
-    totalAssociations: number
-    categoryCounts: Record<string, number>
-  } {
-    return getTemplateStats()
-  }
-}

package/src/modeling/templates/types.ts

@@ -1,175 +0,0 @@
-import type { DataDomain } from '../DataDomain.js'
-
-export interface CreateTemplateOptions {
-  /**
-   * The DataDomain instance to use for the template.
-   * If not provided, a new DataDomain instance will be created.
-   */
-  domain?: DataDomain
-}
-
-/**
- * Template metadata for UI presentation
- */
-export interface DomainTemplate {
-  /** Unique identifier for the template */
-  id: string
-  /** Display name of the template */
-  name: string
-  /** Short description of what the template does (plain text, no HTML/markdown) */
-  description: string
-  /** When the template was created (ISO string) */
-  createdAt: string
-  /** When the template was last updated (ISO string) */
-  updatedAt: string
-  /** Template version */
-  version: string
-  /** Author information */
-  author: string
-  /** Template categorization tags */
-  tags: string[]
-  /** Detailed domain structure for UI presentation */
-  structure: DomainTemplateStructure
-}
-
-/**
- * Detailed domain structure information for UI presentation
- */
-export interface DomainTemplateStructure {
-  /** Domain information */
-  domain: DomainInfo
-  /** List of namespaces in the domain */
-  namespaces: NamespaceInfo[]
-}
-
-/**
- * Domain-level information
- */
-export interface DomainInfo {
-  /** Domain name */
-  name: string
-  /** Domain description */
-  description?: string
-  /** Total number of entities across all namespaces */
-  totalEntities: number
-  /** Total number of properties across all entities */
-  totalProperties: number
-  /** Total number of associations across all entities */
-  totalAssociations: number
-}
-
-/**
- * Namespace-level information
- */
-export interface NamespaceInfo {
-  /** Namespace name */
-  name: string
-  /** Namespace display name */
-  displayName?: string
-  /** Namespace description */
-  description?: string
-  /** Number of models in this namespace */
-  modelCount: number
-  /** Number of entities in this namespace */
-  entityCount: number
-  /** List of models in this namespace */
-  models: ModelInfo[]
-}
-
-/**
- * Model-level information
- */
-export interface ModelInfo {
-  /** Model name */
-  name: string
-  /** Model display name */
-  displayName?: string
-  /** Model description */
-  description?: string
-  /** Number of entities in this model */
-  entityCount: number
-  /** List of entities in this model */
-  entities: EntityInfo[]
-}
-
-/**
- * Entity-level information for UI presentation
- */
-export interface EntityInfo {
-  /** Entity name */
-  name: string
-  /** Entity display name */
-  displayName?: string
-  /** Entity description */
-  description?: string
-  /** Number of properties */
-  propertyCount: number
-  /** Number of associations */
-  associationCount: number
-  /** Whether this entity is deprecated */
-  deprecated?: boolean
-  /** List of properties for this entity */
-  properties: PropertyInfo[]
-  /** List of associations for this entity */
-  associations: AssociationInfo[]
-  /** Applied semantic types */
-  semantics: string[]
-}
-
-/**
- * Property-level information for UI presentation
- */
-export interface PropertyInfo {
-  /** Property name */
-  name: string
-  /** Property display name */
-  displayName?: string
-  /** Property description */
-  description?: string
-  /** Data type (string, number, boolean, etc.) */
-  type: string
-  /** Whether this property is required */
-  required?: boolean
-  /** Whether this property allows multiple values */
-  multiple?: boolean
-  /** Whether this property is a primary key */
-  primary?: boolean
-  /** Whether this property is unique */
-  unique?: boolean
-  /** Whether this property is read-only */
-  readOnly?: boolean
-  /** Whether this property is write-only */
-  writeOnly?: boolean
-  /** Whether this property is deprecated */
-  deprecated?: boolean
-  /** Applied semantic types */
-  semantics: string[]
-  /** Enum values if applicable */
-  enumValues?: string[]
-  /** Default value if specified */
-  defaultValue?: string
-}
-
-/**
- * Association-level information for UI presentation
- */
-export interface AssociationInfo {
-  /** Association name */
-  name: string
-  /** Association display name */
-  displayName?: string
-  /** Association description */
-  description?: string
-  /** Whether this association is required */
-  required?: boolean
-  /** Whether this association allows multiple targets */
-  multiple?: boolean
-  /** Whether this association is read-only */
-  readOnly?: boolean
-  /** Target entity names this association points to */
-  targetEntities: string[]
-  /** Applied semantic types */
-  semantics: string[]
-  /** Relationship cardinality description (e.g., "One-to-Many", "Many-to-Many") */
-  cardinality: string
-}

package/src/modeling/templates/verticals/README.md

@@ -1,122 +0,0 @@
-# Industry Vertical Templates
-
-This directory organizes domain templates by industry verticals to provide better categorization and discovery for users looking for domain-specific templates.
-
-## Structure
-
-```plain
-verticals/
-├── business-services/           # E-commerce, Financial Services, Legal Services
-│   ├── ecommerce-domain.ts
-│   ├── financial-services-domain.ts
-│   └── index.ts
-├── healthcare-life-sciences/    # Healthcare, Pharmaceutical, Research
-│   ├── healthcare-domain.ts
-│   └── index.ts
-├── education-training/          # Education, Corporate Training, Certification
-│   ├── education-domain.ts
-│   └── index.ts
-├── real-estate-construction/    # Real Estate, Construction, Property Management
-│   ├── real-estate-domain.ts
-│   └── index.ts
-├── technology-media/            # Gaming, IoT, Content Management, Social Media
-│   ├── blog-domain.ts
-│   └── index.ts
-├── manufacturing-logistics/     # Manufacturing, Supply Chain, Distribution
-│   └── index.ts
-├── public-sector/              # Government, Non-Profit, Healthcare
-│   └── index.ts
-└── index.ts                    # Main verticals index
-```
-
-## Industry Verticals
-
-### 1. Business Services
-
-- **E-commerce Platform**: Complete e-commerce data domain with product management, orders, customers, and payments
-- **Financial Services Platform**: Comprehensive financial services data domain with accounts, transactions, investments, and compliance
-
-### 2. Healthcare & Life Sciences
-
-- **Healthcare Management Platform**: Comprehensive healthcare data domain with patients, providers, facilities, and medical records
-
-### 3. Education & Training
-
-- **Education Management Platform**: Comprehensive education data domain with students, courses, faculty, and academic management
-
-### 4. Real Estate & Construction
-
-- **Real Estate Management Platform**: Comprehensive real estate data domain with properties, clients, transactions, and marketing
-
-### 5. Technology & Media
-
-- **Blog Publishing Platform**: Complete blog and content publishing data domain with articles, authors, and media management
-
-### 6. Manufacturing & Logistics
-
-- *No templates yet* - Planned for Manufacturing, Supply Chain, Distribution
-
-### 7. Public Sector
-
-- *No templates yet* - Planned for Government, Non-Profit, Healthcare
-
-## Usage
-
-### Importing Templates by Vertical
-
-```typescript
-// Import all verticals
-import { 
-  businessServicesTemplates,
-  healthcareLifeSciencesTemplates,
-  educationTrainingTemplates,
-  realEstateConstructionTemplates,
-  technologyMediaTemplates,
-  manufacturingLogisticsTemplates,
-  publicSectorTemplates 
-} from './verticals/index.js'
-
-// Import specific templates
-import { createEcommerceDomain } from './verticals/business-services/index.js'
-import { createHealthcareDomain } from './verticals/healthcare-life-sciences/index.js'
-```
-
-### Using the Template Registry
-
-```typescript
-import { TemplateRegistry } from './template-registry.js'
-
-// Get all industry verticals
-const verticals = TemplateRegistry.getIndustryVerticals()
-
-// Get templates by vertical
-const businessTemplates = TemplateRegistry.getTemplatesByVertical('business-services')
-```
-
-## Adding New Templates
-
-1. **Choose the appropriate vertical** based on the industry focus
-2. **Create the template file** in the corresponding vertical directory
-3. **Update the vertical's index.ts** to export the new template
-4. **Update the main verticals index.ts** to include the template metadata
-5. **Update the metadata generation script** to include the new template
-6. **Run the build and metadata generation**:
-
-   ```bash
-   npm run build
-   node scripts/generate-template-metadata.js
-   ```
-
-## Template Categories
-
-Each vertical can contain multiple subcategories:
-
-- **Business Services**: E-commerce, Financial Services, Legal Services
-- **Healthcare & Life Sciences**: Healthcare, Pharmaceutical, Research
-- **Education & Training**: Education, Corporate Training, Certification
-- **Real Estate & Construction**: Real Estate, Construction, Property Management
-- **Manufacturing & Logistics**: Manufacturing, Supply Chain, Distribution
-- **Technology & Media**: Gaming, IoT, Content Management, Social Media
-- **Public Sector**: Government, Non-Profit, Healthcare
-
-This organization helps users quickly find templates relevant to their industry and use case.