@schemashift/core 0.3.0 → 0.8.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Project, SourceFile } from 'ts-morph';
+import { Project, CallExpression, Node, SourceFile } from 'ts-morph';
 
 type SchemaLibrary = 'zod' | 'zod-v3' | 'yup' | 'joi' | 'io-ts' | 'valibot' | 'v4' | 'unknown';
 interface SchemaInfo {
@@ -46,6 +46,215 @@ declare class SchemaAnalyzer {
     getProject(): Project;
 }
 
+/**
+ * Represents a single method call in a chain.
+ * e.g., `.email()` or `.min(5, 'Too short')`
+ */
+interface MethodCallInfo {
+    name: string;
+    args: string[];
+    node: CallExpression;
+}
+/**
+ * Represents a full call chain like `yup.string().email().min(5)`.
+ */
+interface CallChainInfo {
+    /** The base expression before the first method, e.g., 'yup' or 'Joi' */
+    base: string;
+    /** The initial factory call, e.g., 'string' from `yup.string()` */
+    factoryMethod: string;
+    /** Arguments to the factory method */
+    factoryArgs: string[];
+    /** All chained method calls after the factory */
+    methods: MethodCallInfo[];
+    /** The outermost call expression node */
+    rootNode: CallExpression;
+}
+/**
+ * Parse a method call chain from the outermost CallExpression.
+ *
+ * Given `yup.string().email().min(5)`, returns:
+ * ```
+ * {
+ *   base: 'yup',
+ *   factoryMethod: 'string',
+ *   factoryArgs: [],
+ *   methods: [
+ *     { name: 'email', args: [] },
+ *     { name: 'min', args: ['5'] }
+ *   ]
+ * }
+ * ```
+ *
+ * Returns `undefined` if the node is not a recognizable method chain
+ * (e.g., it's a standalone function call).
+ */
+declare function parseCallChain(node: CallExpression): CallChainInfo | undefined;
+/**
+ * Build a method chain string from parts.
+ *
+ * ```ts
+ * buildCallChain('z', 'string', [], [
+ *   { name: 'email', args: [] },
+ *   { name: 'min', args: ['5'] },
+ * ])
+ * // => 'z.string().email().min(5)'
+ * ```
+ */
+declare function buildCallChain(base: string, factoryMethod: string, factoryArgs: string[], methods: Array<{
+    name: string;
+    args: string[];
+}>): string;
+/**
+ * Check whether a node is inside a string literal or template literal.
+ */
+declare function isInsideStringLiteral(node: Node): boolean;
+/**
+ * Check whether a node is inside a comment.
+ * Since ts-morph's AST doesn't include comment nodes in the tree,
+ * we check by position against leading/trailing comment ranges.
+ */
+declare function isInsideComment(node: Node, sourceFile: SourceFile): boolean;
+/**
+ * Check if a call expression starts with a specific base identifier.
+ * Traverses into the chain to find the root identifier.
+ *
+ * e.g., `startsWithBase(node, 'yup')` returns true for `yup.string().email()`
+ */
+declare function startsWithBase(node: CallExpression, ...bases: string[]): boolean;
+/**
+ * Transform a method chain by applying a mapping function to each method.
+ * Returns the rebuilt chain as a string, or undefined if no transformation was needed.
+ *
+ * The mapper receives each method and can return:
+ * - `{ name, args }` to transform the method
+ * - `null` to remove the method from the chain
+ * - `undefined` to keep it unchanged
+ * - An array to expand into multiple methods
+ */
+declare function transformMethodChain(chain: CallChainInfo, newBase: string, factoryMapper: (method: string, args: string[]) => {
+    name: string;
+    args: string[];
+} | undefined, methodMapper: (method: MethodCallInfo) => {
+    name: string;
+    args: string[];
+} | {
+    name: string;
+    args: string[];
+}[] | null | undefined): string;
+
+interface TransformHandler {
+    transform(sourceFile: SourceFile, options: TransformOptions): TransformResult;
+}
+declare class TransformEngine {
+    private handlers;
+    registerHandler(from: SchemaLibrary, to: SchemaLibrary, handler: TransformHandler): void;
+    getHandler(from: SchemaLibrary, to: SchemaLibrary): TransformHandler | undefined;
+    hasHandler(from: SchemaLibrary, to: SchemaLibrary): boolean;
+    getSupportedPaths(): Array<{
+        from: SchemaLibrary;
+        to: SchemaLibrary;
+    }>;
+    transform(sourceFile: SourceFile, from: SchemaLibrary, to: SchemaLibrary, options: TransformOptions): TransformResult;
+}
+
+interface ChainStep {
+    from: SchemaLibrary;
+    to: SchemaLibrary;
+}
+interface ChainValidation {
+    valid: boolean;
+    errors: string[];
+    steps: ChainStep[];
+}
+interface ChainStepResult {
+    step: ChainStep;
+    result: TransformResult;
+}
+interface ChainResult {
+    success: boolean;
+    steps: ChainStepResult[];
+    finalCode?: string;
+    errors: string[];
+}
+declare class MigrationChain {
+    parseChain(chain: string): ChainStep[];
+    validateChain(steps: ChainStep[], engine: TransformEngine): ChainValidation;
+    executeChain(sourceCode: string, filePath: string, steps: ChainStep[], engine: TransformEngine): ChainResult;
+}
+
+interface EcosystemIssue {
+    package: string;
+    installedVersion: string;
+    migration: string;
+    issue: string;
+    suggestion: string;
+    severity: 'info' | 'warning' | 'error';
+    category: 'orm' | 'form' | 'api' | 'validation-util' | 'openapi' | 'ui';
+    upgradeCommand?: string;
+}
+interface EcosystemReport {
+    dependencies: EcosystemIssue[];
+    warnings: string[];
+    blockers: string[];
+}
+declare class EcosystemAnalyzer {
+    analyze(projectPath: string, from: string, to: string): EcosystemReport;
+}
+
+interface VersionIssue {
+    library: string;
+    detectedVersion: string;
+    issue: string;
+    suggestion: string;
+    severity: 'info' | 'warning' | 'error';
+}
+interface CompatibilityResult {
+    detectedVersions: Array<{
+        library: string;
+        version: string;
+    }>;
+    issues: VersionIssue[];
+    ecosystemIssues: EcosystemIssue[];
+    overallScore: number;
+}
+declare class CompatibilityAnalyzer {
+    private ecosystemAnalyzer;
+    detectVersions(projectPath: string): Array<{
+        library: string;
+        version: string;
+    }>;
+    checkCompatibility(projectPath: string, from?: string, to?: string): CompatibilityResult;
+}
+
+type EffortLevel = 'trivial' | 'low' | 'moderate' | 'high' | 'extreme';
+interface ComplexityWarning {
+    file: string;
+    line?: number;
+    message: string;
+    severity: 'info' | 'warning' | 'error';
+}
+interface FileComplexity {
+    filePath: string;
+    schemaCount: number;
+    advancedPatterns: string[];
+    chainDepth: number;
+    lineCount: number;
+}
+interface ComplexityEstimate {
+    effort: EffortLevel;
+    totalSchemas: number;
+    totalFiles: number;
+    advancedPatternCount: number;
+    files: FileComplexity[];
+    warnings: ComplexityWarning[];
+    riskAreas: string[];
+}
+declare class ComplexityEstimator {
+    estimate(files: SourceFile[]): ComplexityEstimate;
+    private calculateEffort;
+}
+
 interface SchemaShiftConfig {
     include: string[];
     exclude: string[];
@@ -65,7 +274,22 @@ interface SchemaShiftConfig {
         dir?: string;
     };
     customRules?: CustomRule[];
+    suppressWarnings?: WarningSuppressionRule[];
     ci?: boolean;
+    plugins?: string[];
+    governance?: {
+        rules: Record<string, GovernanceRuleConfig>;
+        failOnViolation?: boolean;
+    };
+}
+interface GovernanceRuleConfig {
+    enabled?: boolean;
+    pattern?: string;
+    threshold?: number;
+}
+interface WarningSuppressionRule {
+    code: string;
+    files?: string[];
 }
 interface CustomRule {
     name: string;
@@ -81,23 +305,204 @@ interface CustomRule {
         warning?: string;
     };
 }
+declare function validateConfig(config: SchemaShiftConfig): {
+    valid: boolean;
+    errors: string[];
+};
+declare function shouldSuppressWarning(warning: string, filePath: string, rules: WarningSuppressionRule[]): boolean;
 declare function loadConfig(configPath?: string): Promise<SchemaShiftConfig>;
 
+interface DependencyGraphResult {
+    /** Files sorted in dependency order (dependencies first) */
+    sortedFiles: string[];
+    /** Map of file -> files it depends on */
+    dependencies: Map<string, string[]>;
+    /** Circular dependency warnings */
+    circularWarnings: string[];
+    /** Total cross-file schema references */
+    crossFileRefs: number;
+}
+declare class SchemaDependencyResolver {
+    resolve(project: Project, filePaths: string[]): DependencyGraphResult;
+    private findDependencies;
+    private detectCycles;
+    private topologicalSort;
+    private shortenPath;
+}
+interface MonorepoPackage {
+    name: string;
+    path: string;
+    schemaLibrary?: string;
+    dependencies: string[];
+}
+interface MonorepoInfo {
+    isMonorepo: boolean;
+    packages: MonorepoPackage[];
+    suggestedOrder: string[];
+}
+declare class MonorepoResolver {
+    detect(projectPath: string): boolean;
+    analyze(projectPath: string): MonorepoInfo;
+    private suggestOrder;
+    private resolveWorkspaceDirs;
+}
+
+interface SchemaComplexity {
+    schemaName: string;
+    filePath: string;
+    library: SchemaLibrary;
+    lineNumber: number;
+    chainLength: number;
+    nestedDepth: number;
+    validationCount: number;
+    score: number;
+    level: 'low' | 'medium' | 'high' | 'critical';
+}
+interface MigrationReadiness {
+    from: SchemaLibrary;
+    to: SchemaLibrary;
+    totalSchemas: number;
+    supportedSchemas: number;
+    unsupportedPatterns: string[];
+    estimatedManualFixes: number;
+    readinessPercent: number;
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+}
+interface LibraryVersionInfo {
+    library: string;
+    version: string;
+}
+interface DetailedAnalysisResult {
+    complexities: SchemaComplexity[];
+    averageComplexity: number;
+    maxComplexity: number;
+    libraryVersions: LibraryVersionInfo[];
+    readiness?: MigrationReadiness;
+}
+declare class DetailedAnalyzer {
+    analyzeComplexity(analyzer: SchemaAnalyzer): SchemaComplexity[];
+    analyzeReadiness(schemas: SchemaInfo[], from: SchemaLibrary, to: SchemaLibrary, supportedMethods: Set<string>): MigrationReadiness;
+    detectLibraryVersions(projectPath: string): LibraryVersionInfo[];
+    generateDetailedResult(complexities: SchemaComplexity[], projectPath: string, readiness?: MigrationReadiness): DetailedAnalysisResult;
+    private computeComplexity;
+    private countChainLength;
+    private countNestedDepth;
+    private countValidations;
+    private extractMethodNames;
+    private getLibraryPrefix;
+    private escapeRegex;
+    private detectFileLibrary;
+    private isSchemaExpression;
+}
+
 declare function detectSchemaLibrary(moduleSpecifier: string): SchemaLibrary;
+interface FormLibraryDetection {
+    library: string;
+    importPath: string;
+    lineNumber: number;
+}
+declare function detectFormLibraries(sourceFile: SourceFile): FormLibraryDetection[];
 
-interface TransformHandler {
-    transform(sourceFile: SourceFile, options: TransformOptions): TransformResult;
+interface FormResolverResult {
+    success: boolean;
+    transformedCode: string;
+    changes: string[];
+    warnings: string[];
 }
-declare class TransformEngine {
-    private handlers;
-    registerHandler(from: SchemaLibrary, to: SchemaLibrary, handler: TransformHandler): void;
-    getHandler(from: SchemaLibrary, to: SchemaLibrary): TransformHandler | undefined;
-    hasHandler(from: SchemaLibrary, to: SchemaLibrary): boolean;
-    getSupportedPaths(): Array<{
+declare class FormResolverMigrator {
+    migrate(sourceFile: SourceFile, from: string, to: string): FormResolverResult;
+}
+
+interface GovernanceViolation {
+    rule: string;
+    message: string;
+    filePath: string;
+    lineNumber: number;
+    schemaName: string;
+    severity: 'warning' | 'error';
+    fixable: boolean;
+}
+interface GovernanceResult {
+    violations: GovernanceViolation[];
+    filesScanned: number;
+    schemasChecked: number;
+    passed: boolean;
+}
+declare class GovernanceEngine {
+    private rules;
+    configure(rules: Record<string, GovernanceRuleConfig>): void;
+    analyze(project: Project): GovernanceResult;
+    private detectFileLibrary;
+    private isSchemaExpression;
+}
+
+interface IncrementalState {
+    migrationId: string;
+    from: SchemaLibrary;
+    to: SchemaLibrary;
+    startedAt: string;
+    completedFiles: string[];
+    remainingFiles: string[];
+    failedFiles: string[];
+}
+declare class IncrementalTracker {
+    private stateDir;
+    private statePath;
+    constructor(projectPath: string);
+    start(files: string[], from: SchemaLibrary, to: SchemaLibrary): IncrementalState;
+    markComplete(filePath: string): void;
+    markFailed(filePath: string): void;
+    getState(): IncrementalState | null;
+    resume(): IncrementalState | null;
+    getNextBatch(batchSize: number): string[];
+    getProgress(): {
+        completed: number;
+        remaining: number;
+        failed: number;
+        total: number;
+        percent: number;
+    } | null;
+    clear(): void;
+    private saveState;
+}
+
+interface PackageUpdatePlan {
+    add: Record<string, string>;
+    remove: string[];
+    warnings: string[];
+}
+declare class PackageUpdater {
+    plan(projectPath: string, from: string, to: string): PackageUpdatePlan;
+    apply(projectPath: string, plan: PackageUpdatePlan): void;
+}
+
+interface SchemaShiftPlugin {
+    name: string;
+    version: string;
+    handlers?: Array<{
         from: SchemaLibrary;
         to: SchemaLibrary;
+        handler: TransformHandler;
     }>;
-    transform(sourceFile: SourceFile, from: SchemaLibrary, to: SchemaLibrary, options: TransformOptions): TransformResult;
+    rules?: CustomRule[];
+}
+interface PluginLoadResult {
+    loaded: SchemaShiftPlugin[];
+    errors: string[];
+}
+declare class PluginLoader {
+    loadPlugins(pluginPaths: string[]): Promise<PluginLoadResult>;
+    private validatePlugin;
+}
+
+interface StandardSchemaInfo {
+    detected: boolean;
+    compatibleLibraries: Array<{
+        name: string;
+        version: string;
+    }>;
+    recommendation: string;
 }
+declare function detectStandardSchema(projectPath: string): StandardSchemaInfo;
 
-export { type AnalysisResult, type CustomRule, SchemaAnalyzer, type SchemaInfo, type SchemaLibrary, type SchemaShiftConfig, TransformEngine, type TransformError, type TransformHandler, type TransformOptions, type TransformResult, detectSchemaLibrary, loadConfig };
+export { type AnalysisResult, type CallChainInfo, type ChainResult, type ChainStep, type ChainStepResult, type ChainValidation, CompatibilityAnalyzer, type CompatibilityResult, type ComplexityEstimate, ComplexityEstimator, type ComplexityWarning, type CustomRule, type DependencyGraphResult, type DetailedAnalysisResult, DetailedAnalyzer, EcosystemAnalyzer, type EcosystemIssue, type EcosystemReport, type EffortLevel, type FileComplexity, type FormLibraryDetection, FormResolverMigrator, type FormResolverResult, GovernanceEngine, type GovernanceResult, type GovernanceRuleConfig, type GovernanceViolation, type IncrementalState, IncrementalTracker, type LibraryVersionInfo, type MethodCallInfo, MigrationChain, type MigrationReadiness, type MonorepoInfo, type MonorepoPackage, MonorepoResolver, type PackageUpdatePlan, PackageUpdater, type PluginLoadResult, PluginLoader, SchemaAnalyzer, type SchemaComplexity, SchemaDependencyResolver, type SchemaInfo, type SchemaLibrary, type SchemaShiftConfig, type SchemaShiftPlugin, type StandardSchemaInfo, TransformEngine, type TransformError, type TransformHandler, type TransformOptions, type TransformResult, type VersionIssue, type WarningSuppressionRule, buildCallChain, detectFormLibraries, detectSchemaLibrary, detectStandardSchema, isInsideComment, isInsideStringLiteral, loadConfig, parseCallChain, shouldSuppressWarning, startsWithBase, transformMethodChain, validateConfig };