@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/kappa-mongoose-generator.js

@@ -0,0 +1,442 @@
+// =============================================================================
+// Kappa v2.5 Mongoose Schema Generator
+// =============================================================================
+//
+// Generates Mongoose schema code from Kappa entity blocks.
+// Supports MongoDB with TypeScript type definitions.
+//
+// =============================================================================
+// Type Mappings
+// =============================================================================
+const PRIMITIVE_TYPE_MAP = {
+    string: 'String',
+    int: 'Number',
+    float: 'Number',
+    bool: 'Boolean',
+    email: 'String',
+    url: 'String',
+    uuid: 'String',
+    phone: 'String',
+    slug: 'String',
+    markdown: 'String',
+    json: 'Schema.Types.Mixed',
+    timestamp: 'Date',
+    date: 'Date',
+    time: 'String',
+    duration: 'Number',
+};
+const TYPESCRIPT_TYPE_MAP = {
+    string: 'string',
+    int: 'number',
+    float: 'number',
+    bool: 'boolean',
+    email: 'string',
+    url: 'string',
+    uuid: 'string',
+    phone: 'string',
+    slug: 'string',
+    markdown: 'string',
+    json: 'any',
+    timestamp: 'Date',
+    date: 'Date',
+    time: 'string',
+    duration: 'number',
+};
+// =============================================================================
+// Generator Class
+// =============================================================================
+export class KappaMongooseGenerator {
+    typescript;
+    provenance;
+    separateTypes;
+    constructor(options = {}) {
+        this.typescript = options.typescript ?? true;
+        this.provenance = options.provenance ?? true;
+        this.separateTypes = options.separateTypes ?? true;
+    }
+    /**
+     * Generate Mongoose schema from entity blocks
+     */
+    generate(entities) {
+        const schema = this.generateSchemaFile(entities);
+        const result = { schema };
+        if (this.typescript && this.separateTypes) {
+            result.types = this.generateTypesFile(entities);
+        }
+        return result;
+    }
+    // ===========================================================================
+    // Schema File Generation
+    // ===========================================================================
+    generateSchemaFile(entities) {
+        const lines = [];
+        // Header comment
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// Mongoose Schema for MongoDB');
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push(this.generateSchemaImports(entities));
+        lines.push('');
+        // Generate each schema
+        for (const entity of entities) {
+            lines.push(this.generateSchema(entity, entities));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    generateSchemaImports(entities) {
+        const imports = ['Schema', 'model', 'Document'];
+        // Check if we need Types for Mixed
+        for (const entity of entities) {
+            for (const field of entity.fields) {
+                if (this.fieldUsesSchemaTypes(field.type)) {
+                    imports.push('Types');
+                    break;
+                }
+            }
+        }
+        const mongooseImport = `import { ${imports.join(', ')} } from 'mongoose';`;
+        if (this.typescript && this.separateTypes) {
+            // Import types from separate file
+            const typeImports = entities
+                .map(e => `${e.name}Document`)
+                .join(', ');
+            return `${mongooseImport}\nimport type { ${typeImports} } from './types';`;
+        }
+        return mongooseImport;
+    }
+    fieldUsesSchemaTypes(type) {
+        if (type.kind === 'primitive' && type.type === 'json') {
+            return true;
+        }
+        if (type.kind === 'reference') {
+            return true;
+        }
+        if (type.kind === 'array' && type.itemType.kind === 'reference') {
+            return true;
+        }
+        return false;
+    }
+    generateSchema(entity, allEntities) {
+        const schemaName = `${entity.name}Schema`;
+        const modelName = entity.name;
+        const lines = [];
+        // Interface definition (if TypeScript and not separate)
+        if (this.typescript && !this.separateTypes) {
+            lines.push(this.generateInterface(entity, allEntities));
+            lines.push('');
+        }
+        // Schema definition
+        lines.push(`const ${schemaName} = new Schema<${modelName}Document>({`);
+        // Generate fields
+        for (const field of entity.fields) {
+            lines.push(`  ${this.generateField(field, entity)},`);
+        }
+        // Generate foreign key fields for belongs_to relationships
+        for (const rel of entity.relationships) {
+            if (rel.type === 'belongs_to') {
+                lines.push(`  ${this.generateRelationshipField(rel)},`);
+            }
+        }
+        lines.push('}, {');
+        lines.push('  timestamps: true,');
+        lines.push('  collection: \'' + this.toSnakeCase(entity.name) + '\',');
+        lines.push('});');
+        // Generate indexes
+        if (entity.indexes.length > 0) {
+            lines.push('');
+            lines.push(this.generateIndexes(entity, schemaName));
+        }
+        // Generate virtual relationships
+        const virtuals = this.generateVirtualRelationships(entity, allEntities, schemaName);
+        if (virtuals) {
+            lines.push('');
+            lines.push(virtuals);
+        }
+        // Export model
+        lines.push('');
+        lines.push(`export const ${modelName} = model<${modelName}Document>('${modelName}', ${schemaName});`);
+        return lines.join('\n');
+    }
+    generateField(field, entity) {
+        const { name, type, modifiers } = field;
+        const fieldDef = [];
+        // Type
+        const mongooseType = this.getMongooseType(type);
+        fieldDef.push(`type: ${mongooseType}`);
+        // Handle modifiers
+        if (modifiers.includes('primary')) {
+            // MongoDB uses _id automatically, but if explicitly marked primary
+            if (name !== 'id') {
+                fieldDef.push('unique: true');
+            }
+        }
+        if (modifiers.includes('unique')) {
+            fieldDef.push('unique: true');
+        }
+        if (!modifiers.includes('optional') && !modifiers.includes('primary')) {
+            fieldDef.push('required: true');
+        }
+        if (modifiers.includes('immutable')) {
+            fieldDef.push('immutable: true');
+        }
+        // Auto-increment or default values
+        if (modifiers.includes('auto')) {
+            if (type.kind === 'primitive') {
+                if (type.type === 'uuid') {
+                    fieldDef.push('default: () => new Types.ObjectId().toString()');
+                }
+                else if (type.type === 'timestamp' || type.type === 'date') {
+                    fieldDef.push('default: Date.now');
+                }
+            }
+        }
+        // Update trigger (for updated_at fields)
+        if (field.updateTrigger) {
+            // Mongoose handles this via timestamps option
+            // But we can add a pre-save hook comment
+        }
+        // Default values
+        if (field.defaultValue !== undefined) {
+            if (type.kind === 'enum') {
+                fieldDef.push(`default: '${field.defaultValue}'`);
+            }
+            else if (type.kind === 'primitive') {
+                if (type.type === 'bool') {
+                    fieldDef.push(`default: ${field.defaultValue}`);
+                }
+                else if (type.type === 'string' || type.type === 'email' || type.type === 'url' ||
+                    type.type === 'phone' || type.type === 'slug' || type.type === 'markdown') {
+                    fieldDef.push(`default: '${field.defaultValue}'`);
+                }
+                else if (type.type === 'int' || type.type === 'float' || type.type === 'duration') {
+                    fieldDef.push(`default: ${field.defaultValue}`);
+                }
+            }
+        }
+        // Validators
+        const validators = this.generateValidators(field);
+        if (validators.length > 0) {
+            fieldDef.push(...validators);
+        }
+        // Enum values
+        if (type.kind === 'enum') {
+            fieldDef.push(`enum: [${type.values.map(v => `'${v}'`).join(', ')}]`);
+        }
+        // Handle range constraints
+        if (type.kind === 'primitive' && type.range) {
+            if (type.type === 'string' && type.range.max) {
+                fieldDef.push(`maxlength: ${type.range.max}`);
+            }
+            if (type.type === 'string' && type.range.min) {
+                fieldDef.push(`minlength: ${type.range.min}`);
+            }
+            if ((type.type === 'int' || type.type === 'float') && type.range.min !== undefined) {
+                fieldDef.push(`min: ${type.range.min}`);
+            }
+            if ((type.type === 'int' || type.type === 'float') && type.range.max !== undefined) {
+                fieldDef.push(`max: ${type.range.max}`);
+            }
+        }
+        // Skip _id field as Mongoose handles it
+        if (name === 'id' && modifiers.includes('primary') && modifiers.includes('auto')) {
+            return '// _id is handled automatically by MongoDB';
+        }
+        return `${name}: { ${fieldDef.join(', ')} }`;
+    }
+    generateRelationshipField(rel) {
+        const fieldName = `${this.toCamelCase(rel.entity)}Id`;
+        const refModel = rel.entity;
+        return `${fieldName}: { type: Schema.Types.ObjectId, ref: '${refModel}' }`;
+    }
+    generateValidators(field) {
+        const validators = [];
+        if (field.type.kind === 'primitive') {
+            switch (field.type.type) {
+                case 'email':
+                    validators.push('validate: { validator: (v: string) => /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(v), message: \'Invalid email format\' }');
+                    break;
+                case 'url':
+                    validators.push('validate: { validator: (v: string) => /^https?:\\/\\/.+/.test(v), message: \'Invalid URL format\' }');
+                    break;
+                case 'phone':
+                    validators.push('validate: { validator: (v: string) => /^\\+?[1-9]\\d{1,14}$/.test(v), message: \'Invalid phone format\' }');
+                    break;
+                case 'uuid':
+                    validators.push('validate: { validator: (v: string) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(v), message: \'Invalid UUID format\' }');
+                    break;
+            }
+        }
+        return validators;
+    }
+    getMongooseType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return PRIMITIVE_TYPE_MAP[type.type];
+            case 'enum':
+                return 'String';
+            case 'reference':
+                return 'Schema.Types.ObjectId';
+            case 'array':
+                if (type.itemType.kind === 'reference') {
+                    return `[{ type: Schema.Types.ObjectId, ref: '${type.itemType.entity}' }]`;
+                }
+                else if (type.itemType.kind === 'primitive') {
+                    return `[${PRIMITIVE_TYPE_MAP[type.itemType.type]}]`;
+                }
+                else {
+                    return '[Schema.Types.Mixed]';
+                }
+            default:
+                return 'Schema.Types.Mixed';
+        }
+    }
+    generateIndexes(entity, schemaName) {
+        const lines = [];
+        for (const index of entity.indexes) {
+            const fields = index.fields.map(f => `${f}: 1`).join(', ');
+            const unique = index.unique ? ', { unique: true }' : '';
+            lines.push(`${schemaName}.index({ ${fields} }${unique});`);
+        }
+        return lines.join('\n');
+    }
+    generateVirtualRelationships(entity, allEntities, schemaName) {
+        const virtuals = [];
+        for (const rel of entity.relationships) {
+            const relName = rel.as || this.toCamelCase(rel.entity);
+            const refModel = rel.entity;
+            const localField = rel.type === 'belongs_to' ? `${this.toCamelCase(rel.entity)}Id` : '_id';
+            const foreignField = rel.type === 'belongs_to' ? '_id' : `${this.toCamelCase(entity.name)}Id`;
+            switch (rel.type) {
+                case 'has_many':
+                    virtuals.push(`${schemaName}.virtual('${relName}', {`);
+                    virtuals.push(`  ref: '${refModel}',`);
+                    virtuals.push(`  localField: '${localField}',`);
+                    virtuals.push(`  foreignField: '${foreignField}',`);
+                    if (rel.through) {
+                        virtuals.push(`  // Many-to-many through ${rel.through}`);
+                    }
+                    virtuals.push('});');
+                    break;
+                case 'has_one':
+                    virtuals.push(`${schemaName}.virtual('${relName}', {`);
+                    virtuals.push(`  ref: '${refModel}',`);
+                    virtuals.push(`  localField: '${localField}',`);
+                    virtuals.push(`  foreignField: '${foreignField}',`);
+                    virtuals.push('  justOne: true,');
+                    virtuals.push('});');
+                    break;
+                // belongs_to is handled via direct reference field
+            }
+        }
+        if (virtuals.length === 0)
+            return null;
+        return virtuals.join('\n');
+    }
+    // ===========================================================================
+    // TypeScript Interface Generation
+    // ===========================================================================
+    generateInterface(entity, allEntities) {
+        const lines = [];
+        lines.push(`export interface ${entity.name}Document extends Document {`);
+        // Generate field types
+        for (const field of entity.fields) {
+            if (field.name === 'id' && field.modifiers.includes('primary')) {
+                // Skip - Document already has _id
+                continue;
+            }
+            const tsType = this.getTypeScriptType(field.type);
+            const optional = field.modifiers.includes('optional') ? '?' : '';
+            lines.push(`  ${field.name}${optional}: ${tsType};`);
+        }
+        // Generate relationship types
+        for (const rel of entity.relationships) {
+            const relName = rel.as || this.toCamelCase(rel.entity);
+            const refType = rel.entity;
+            switch (rel.type) {
+                case 'belongs_to':
+                    const fieldName = `${this.toCamelCase(rel.entity)}Id`;
+                    lines.push(`  ${fieldName}?: Types.ObjectId;`);
+                    lines.push(`  ${relName}?: ${refType}Document;`);
+                    break;
+                case 'has_many':
+                    lines.push(`  ${relName}?: ${refType}Document[];`);
+                    break;
+                case 'has_one':
+                    lines.push(`  ${relName}?: ${refType}Document;`);
+                    break;
+            }
+        }
+        // Mongoose timestamps
+        lines.push('  createdAt: Date;');
+        lines.push('  updatedAt: Date;');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    getTypeScriptType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return TYPESCRIPT_TYPE_MAP[type.type];
+            case 'enum':
+                return type.values.map(v => `'${v}'`).join(' | ');
+            case 'reference':
+                return `Types.ObjectId | ${type.entity}Document`;
+            case 'array':
+                if (type.itemType.kind === 'reference') {
+                    return `(Types.ObjectId | ${type.itemType.entity}Document)[]`;
+                }
+                else if (type.itemType.kind === 'primitive') {
+                    return `${TYPESCRIPT_TYPE_MAP[type.itemType.type]}[]`;
+                }
+                else {
+                    return 'any[]';
+                }
+            default:
+                return 'any';
+        }
+    }
+    // ===========================================================================
+    // Types File Generation
+    // ===========================================================================
+    generateTypesFile(entities) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// TypeScript types for Mongoose models');
+            lines.push('');
+        }
+        lines.push(`import type { Document, Types } from 'mongoose';`);
+        lines.push('');
+        // Generate interfaces for each entity
+        for (const entity of entities) {
+            lines.push(this.generateInterface(entity, entities));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Utilities
+    // ===========================================================================
+    toSnakeCase(str) {
+        return str
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '');
+    }
+    toCamelCase(str) {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+}
+// =============================================================================
+// Convenience Function
+// =============================================================================
+/**
+ * Generate Mongoose schema from Kappa entities
+ */
+export function generateMongooseSchema(entities, options = {}) {
+    const generator = new KappaMongooseGenerator(options);
+    return generator.generate(entities);
+}

package/dist/codedna/kappa-parser.d.ts

@@ -1,5 +1,5 @@
 import { CstParser, IToken, CstNode } from 'chevrotain';
-import { KappaSpec, ProjectBlock, AuthBlock, HashConfig, EntityBlock, EntityField, FieldType, FieldModifier, EntityRelationship, Capability, LifecycleHook, APIBlock, APIOperation, APIReturnType, CRUDShorthand, CRUDAction, EffectType, APIParameter, JourneyBlock, JourneyStep, PageBlock, ComponentBlock, FormBlock, FormField, DesignBlock } from './kappa-ast.js';
+import { KappaSpec, ProjectBlock, AuthBlock, HashConfig, EntityBlock, EntityField, FieldType, FieldModifier, EntityRelationship, Capability, LifecycleHook, APIBlock, APIOperation, APIReturnType, CRUDShorthand, CRUDAction, EffectType, APIParameter, JourneyBlock, JourneyStep, PageBlock, ComponentBlock, FormBlock, FormField, DesignBlock, TestBlock, TestSuite, TestCase, TestAssertion, TestMock } from './kappa-ast.js';
 declare class KappaParser extends CstParser {
     constructor();
     kappaSpec: import("chevrotain").ParserMethod<[], CstNode>;
@@ -73,6 +73,18 @@ declare class KappaParser extends CstParser {
     typographyDefinition: import("chevrotain").ParserMethod<[], CstNode>;
     spacingDefinition: import("chevrotain").ParserMethod<[], CstNode>;
     animationDefinition: import("chevrotain").ParserMethod<[], CstNode>;
+    testBlock: import("chevrotain").ParserMethod<[], CstNode>;
+    testProperty: import("chevrotain").ParserMethod<[], CstNode>;
+    coverageProperty: import("chevrotain").ParserMethod<[], CstNode>;
+    testSuite: import("chevrotain").ParserMethod<[], CstNode>;
+    testLifecycle: import("chevrotain").ParserMethod<[], CstNode>;
+    testMock: import("chevrotain").ParserMethod<[], CstNode>;
+    mockProperty: import("chevrotain").ParserMethod<[], CstNode>;
+    testCase: import("chevrotain").ParserMethod<[], CstNode>;
+    testCaseSection: import("chevrotain").ParserMethod<[], CstNode>;
+    testAssertion: import("chevrotain").ParserMethod<[], CstNode>;
+    assertionProperty: import("chevrotain").ParserMethod<[], CstNode>;
+    assertionType: import("chevrotain").ParserMethod<[], CstNode>;
 }
 declare const parser: KappaParser;
 declare const BaseCstVisitor: new (...args: any[]) => import("chevrotain").ICstVisitor<any, any>;
@@ -242,6 +254,36 @@ declare class KappaAstBuilder extends BaseCstVisitor {
         name: string;
         value: string;
     };
+    testBlock(ctx: Record<string, unknown>): TestBlock;
+    testProperty(ctx: Record<string, unknown>): {
+        type: string;
+        value: unknown;
+    };
+    coverageProperty(ctx: Record<string, IToken[]>): {
+        name: string;
+        value: number;
+    };
+    testSuite(ctx: Record<string, unknown>): TestSuite;
+    testLifecycle(ctx: Record<string, unknown>): {
+        type: string;
+        statements: string[];
+    };
+    testMock(ctx: Record<string, unknown>): TestMock;
+    mockProperty(ctx: Record<string, unknown>): {
+        type: string;
+        value: string;
+    };
+    testCase(ctx: Record<string, unknown>): TestCase;
+    testCaseSection(ctx: Record<string, unknown>): {
+        type: string;
+        value: unknown;
+    };
+    testAssertion(ctx: Record<string, unknown>): TestAssertion;
+    assertionProperty(ctx: Record<string, unknown>): {
+        name: string;
+        value: string;
+    };
+    assertionType(ctx: Record<string, IToken[]>): string;
 }
 export interface ParseResult {
     success: boolean;