Data Model Explanation

This page provides a comprehensive explanation of the data model used to represent company analysis results. The model is defined using TypeScript interfaces to ensure type safety, consistency, and clarity when handling complex company data.

Overview

At the highest level, the data model is represented by the CompanyAnalysisResult interface. It encapsulates three main parts:

• metadata: General information such as status codes, titles, and descriptions.
• data: The main container holding detailed company analysis, including company profile, financials, team, and project data.
• pagination: Details used for paginating the results (this can be further refined to a specific type if needed).

export interface CompanyAnalysisResult {
  metadata: Metadata;
  data: Data;
  pagination: any; // adjust if you have a specific pagination type
}

Metadata

The Metadata interface holds basic descriptive information about the analysis result:

• code: A string representing a status or error code.
• title: A short title summarizing the analysis.
• description: A detailed description providing further context.

export interface Metadata {
  code: string;
  title: string;
  description: string;
}

Main Data Object

The core of the data model is defined by the Data interface. It contains:

• analysisData: An object of type AnalysisData that holds the detailed analytical data.
• kruncherEntityCompanyId and kruncherEntityCompanyDomainsCsv: Identifiers and domain information related to the company.
• founders: An array of Founder objects, detailing information about the company’s founders.
• projectId and project: References that connect this analysis to a specific project.

export interface Data {
  analysisData: AnalysisData;
  kruncherEntityCompanyId: string;
  kruncherEntityCompanyDomainsCsv: string;
  founders: Founder[];
  projectId: string;
  project: Project;
}

Analysis Data

The AnalysisData interface is a detailed collection of various company data points. Key attributes include:

• companyLogoUrl, companyName, keywordSummary, companyOneSentence, companyLegalName: Core identifiers and summaries for the company.
• website, email, foundYear: Contact information and historical data.
• numberOfEmployees, totalSales, fundsRaised: Quantitative metrics.
• officeLocation, geography, customersNumber: Geographical and customer-related data.
• companyStatus, prosAndCons: Qualitative assessments and structured evaluations.
• insightTeam, executiveStructured: Detailed information about the company’s team and leadership.

Each field in this interface is represented using a generic DataField structure, ensuring consistency across different data types.

export interface AnalysisData {
  companyLogoUrl: DataField;
  companyName: DataField;
  keywordSummary: DataField;
  companyOneSentence: DataField;
  companyLegalName: DataField;
  website: DataField;
  email: DataField;
  foundYear: DataField & { dataPoint: DataPoint };
  officeLocation: DataField;
  numberOfEmployees: DataField & { dataPoint: DataPoint };
  totalSales: DataField & { dataPoint: DataPoint };
  burnRate: DataField;
  geography: DataField;
  fundsRaised: DataField & { dataPoint: DataPoint };
  customersNumber: DataField;
  // ... additional fields follow
}

Generic Data Field

The DataField interface is a reusable template for representing individual data points. It provides:

• text: The primary textual value, which can be null.
• structuredData: Optional detailed or complex data.
• type: A string indicating the data type.
• source: The origin of the data.
• sources: An optional array of additional sources.
• comments: Any supplementary comments or annotations.
• dataPoint: For numeric or date values, a standardized sub-object is provided.

export interface DataField<T = any> {
  text: string | null;
  structuredData?: T;
  type: string;
  source: string;
  sources?: Source[];
  comments?: any[];
  dataPoint?: DataPoint;
}

DataPoint and Source

For fields that capture numeric or date information, the DataPoint interface provides a consistent structure:

• id: Unique identifier for the data point.
• dataType: Type description (e.g., number, date).
• integerValue/floatValue/dateValue: The actual value, stored in an appropriate format.
• unitMeasure: The unit of measurement (if applicable).
• createdAt/updatedAt: Timestamps for tracking changes.
• analysisreportrowId: A link to the corresponding analysis report row.

The Source interface details where data originates from, including reference numbers and logic used.

export interface DataPoint {
  id: string;
  dataType: string;
  integerValue?: number;
  floatValue?: number;
  dateValue?: string | null;
  unitMeasure?: string;
  createdAt: string;
  updatedAt: string;
  analysisreportrowId: string;
}
 
export interface Source {
  referenceNumber: string;
  file: string;
  logic: string;
}

Additional Structured Data

Several other interfaces provide additional structure and context within the data model:

• CompanyStatus: Contains status information and underlying logic.
• ProsAndCons: Captures detailed positive and negative aspects of the company.
• Executive/Founder: Detailed profiles for key personnel, including roles, experience, education, and more. Note that the Founder interface extends the Executive interface.
• Project: Connects analysis results to specific projects, including project metadata and associated scores.
• ProjectScore, Criterion, RedFlag: Used to evaluate projects based on defined criteria, and highlight any concerns or warnings.
• InsightTeam, BusinessMetricsHistorical, and others: Provide insight into team composition, historical performance metrics, market data, and more.

Each of these interfaces is designed to encapsulate specific aspects of the company’s analysis, ensuring that the overall model remains modular, scalable, and easy to maintain.

Conclusion

The presented data model is robust and comprehensive, supporting detailed analysis of company performance, structure, and potential. By using TypeScript interfaces, the model enforces a consistent structure across different data points, which aids in validation, data processing, and integration with other systems.

This structured approach helps ensure that every piece of data—from basic company details to complex financial metrics and team insights—is accurately captured and easily accessible for analysis and reporting.

Happy coding!