@slingr/cli 0.0.2 → 0.0.4

package/dist/templates/prompt-script-generation.md.template

@@ -1,259 +1,259 @@
-# Generate Realistic Dataset Script: "{{DATASOURCE}}-{{DATASET}}"
-
-## ⚠️ CRITICAL: DO NOT MODIFY MODELS
-**Your task is to generate a TypeScript script that creates realistic synthetic data.**
-**DO NOT modify, suggest changes to, or question the model definitions.**
-The models in `src/data/*.ts` are correct and final. Your script must generate data that fits these exact models.
-
----
-
-## Project Context
-{{PROJECT_DESCRIPTION}}
-
-## Task Overview
-Generate a **complete, production-ready TypeScript script** that creates {{TOTAL_RECORDS}} realistic records ({{COUNT}} per model) for the dataset `{{DATASOURCE}}-{{DATASET}}`.
-
-### Target Models (READ-ONLY, DO NOT MODIFY)
-{{MODEL_DESCRIPTIONS}}
-
----
-
-## Script Requirements
-
-### 1. **Data Realism - Top Priority**
-Your generated data MUST be:
-- ✅ **Realistic**: Use appropriate Faker.js methods for each field type and name
-- ✅ **Coherent**: Related fields must make logical sense together
-- ✅ **Domain-appropriate**: Values should reflect real business scenarios
-- ✅ **Diverse**: Include typical values, edge cases, and variations
-
-### 2. **Smart Field Generation**
-Use intelligent generation based on field names and types:
-
-```typescript
-// ❌ BAD: Generic random data
-firstName: faker.lorem.word() // → "dolor"
-
-// ✅ GOOD: Contextual, realistic data  
-firstName: faker.person.firstName() // → "María"
-```
-
-**Field Name Patterns to Handle:**
-- `firstName`, `first_name` → `faker.person.firstName()`
-- `lastName`, `last_name` → `faker.person.lastName()`
-- `email` → `faker.internet.email()`
-- `phone`, `phoneNumber` → `faker.phone.number()`
-- `age` → `faker.number.int({ min: 18, max: 85 })`
-- `company`, `companyName` → `faker.company.name()`
-- `address`, `street` → `faker.location.streetAddress()`
-- `city` → `faker.location.city()`
-- `country` → `faker.location.country()`
-- `zipCode`, `postalCode` → `faker.location.zipCode()`
-- `price`, `amount` → Appropriate range based on context
-- `description` → `faker.lorem.paragraph()` or `faker.commerce.productDescription()`
-- `url`, `website` → `faker.internet.url()`
-- `date`, `createdAt` → `faker.date.past()` or `faker.date.recent()`
-
-### 3. **Field Constraint Compliance**
-Your script MUST respect ALL model constraints:
-- ✅ **Required fields**: Never null/undefined when required
-- ✅ **Length constraints**: Stay within minLength/maxLength bounds
-- ✅ **Numeric ranges**: Respect min/max values
-- ✅ **Regex patterns**: Generate values that match the pattern
-- ✅ **Conditional required/available**: Handle age-dependent fields correctly
-
-### 4. **Relationship Handling**
-For compositions and references:
-- **Compositions**: Generate complete nested objects with all required fields
-- **References**: Reuse previously generated records when possible
-- **Consistency**: Ensure referential integrity across related models
-
-### 5. **Conditional Logic**
-Handle field dependencies correctly:
-
-```typescript
-// Example: parentEmail only required if age < 18
-const age = faker.number.int({ min: 1, max: 90 });
-const person = {
-  age,
-  parentEmail: age < 18 ? faker.internet.email() : undefined,
-  // ... other fields
-};
-```
-
----
-
-## Script Template
-
-Complete this template with realistic data generation:
-
-```typescript
-/**
- * Realistic Dataset Generator for {{PROJECT_NAME}}
- * Dataset: {{DATASOURCE}}-{{DATASET}}
- * Generated: {{TIMESTAMP}}
- * 
- * ⚠️ This script generates synthetic data for testing.
- * All data must pass model validation constraints.
- */
-
-import { faker } from '@faker-js/faker';
-import fs from 'fs-extra';
-import path from 'path';
-
-class {{DATASET_CLASS_NAME}}Generator {
-  private outputDir: string;
-
-  constructor() {
-    this.outputDir = path.join(
-      process.cwd(), 
-      'src', 
-      'datasets', 
-      '{{DATASOURCE}}-{{DATASET}}'
-    );
-    
-    // Set seed for reproducible results
-    faker.seed({{SEED}});
-    
-    // Use locale: {{LOCALE}}
-    // faker.locale = '{{LOCALE}}';
-  }
-
-  async generateAll(): Promise<void> {
-    console.log('🎯 Generating {{TOTAL_RECORDS}} realistic records...\n');
-    await fs.ensureDir(this.outputDir);
-    
-    // TODO: Call generation methods in dependency order
-    // Models with no dependencies should be generated first
-    // Example:
-    // await this.generateAddressData();
-    // await this.generatePersonData();
-    
-    console.log('\n🎉 Dataset generation completed successfully!');
-    console.log(`📁 Output: ${this.outputDir}`);
-    console.log('\n💡 Next step: slingr ds {{DATASOURCE}} load {{DATASET}}');
-  }
-
-  // TODO: Implement generation methods for each model
-  // Use the examples below as templates:
-
-  /**
-   * Example generation method - adapt for each model
-   */
-  private async generateExampleData(): Promise<void> {
-    console.log('📝 Generating Example records...');
-    
-    const records = [];
-    for (let i = 0; i < {{COUNT}}; i++) {
-      const record = {
-        // Generate each field with appropriate Faker method
-        // id: faker.string.uuid(), // if not auto-generated
-        // name: faker.person.fullName(),
-        // email: faker.internet.email(),
-        // age: faker.number.int({ min: 18, max: 85 }),
-        // createdAt: faker.date.past().toISOString(),
-        // isActive: faker.datatype.boolean(),
-      };
-      
-      records.push(record);
-    }
-    
-    await this.saveToFile(records, 'Example');
-    console.log(`✅ Generated ${records.length} Example records`);
-  }
-
-  /**
-   * Save records to JSONL file
-   */
-  private async saveToFile<T>(records: T[], modelName: string): Promise<void> {
-    const filePath = path.join(this.outputDir, `${modelName}.jsonl`);
-    const jsonlContent = records.map(r => JSON.stringify(r)).join('\n');
-    await fs.writeFile(filePath, jsonlContent, 'utf-8');
-  }
-}
-
-// Execute if run directly
-if (require.main === module) {
-  new {{DATASET_CLASS_NAME}}Generator()
-    .generateAll()
-    .then(() => {
-      console.log('✨ Success! Dataset is ready to load.');
-      process.exit(0);
-    })
-    .catch((error) => {
-      console.error('❌ Generation failed:', error.message);
-      console.error(error.stack);
-      process.exit(1);
-    });
-}
-
-export { {{DATASET_CLASS_NAME}}Generator };
-```
-
----
-
-## Your Deliverable
-
-Provide a **complete, runnable TypeScript script** that:
-
-1. ✅ Generates {{COUNT}} realistic records for each of the {{TOTAL_MODELS}} models
-2. ✅ Uses appropriate Faker.js methods based on field names and types
-3. ✅ Respects ALL field constraints (required, min/max, regex, etc.)
-4. ✅ Handles conditional fields correctly (e.g., age-based requirements)
-5. ✅ Creates coherent data where related fields make logical sense
-6. ✅ Maintains referential integrity for relationships
-7. ✅ Includes proper error handling and logging
-8. ✅ Can be executed with: `npm run build && node dist/scripts/generate-{{DATASOURCE}}-{{DATASET}}.js`
-
----
-
-## Quality Checklist
-
-Before providing your script, verify:
-
-- [ ] All model field names are spelled correctly
-- [ ] Each field uses an appropriate Faker.js method
-- [ ] Required fields are never null/undefined
-- [ ] Length and numeric constraints are respected
-- [ ] Conditional logic (age-based, etc.) is implemented
-- [ ] Relationships are handled properly
-- [ ] The script has no syntax errors
-- [ ] All imports are correct
-- [ ] The script is complete and ready to run
-
----
-
-## Example of Good vs. Bad Data Generation
-
-### ❌ Bad Example (Avoid This):
-```typescript
-{
-  firstName: faker.lorem.word(),           // → "dolor"
-  lastName: faker.lorem.word(),            // → "ipsum" 
-  email: faker.lorem.word(),               // → "sit" (invalid!)
-  age: faker.number.int({ min: 0, max: 200 }), // → 187 (unrealistic)
-  phoneNumber: faker.lorem.word(),         // → "amet" (invalid!)
-}
-```
-
-### ✅ Good Example (Follow This):
-```typescript
-{
-  firstName: faker.person.firstName(),     // → "María"
-  lastName: faker.person.lastName(),       // → "García"
-  email: faker.internet.email(),           // → "maria.garcia@example.com"
-  age: faker.number.int({ min: 18, max: 85 }), // → 34 (realistic)
-  phoneNumber: faker.phone.number(),       // → "+1-234-567-8900"
-}
-```
-
----
-
-## Technical Details
-- **Framework**: Slingr Framework (TypeScript + TypeORM)
-- **Output Format**: JSONL (one JSON object per line)
-- **Library**: @faker-js/faker (already installed)
-- **Seed**: {{SEED}} (for reproducible results)
-- **Locale**: {{LOCALE}}
-
+# Generate Realistic Dataset Script: "{{DATASOURCE}}-{{DATASET}}"
+
+## ⚠️ CRITICAL: DO NOT MODIFY MODELS
+**Your task is to generate a TypeScript script that creates realistic synthetic data.**
+**DO NOT modify, suggest changes to, or question the model definitions.**
+The models in `src/data/*.ts` are correct and final. Your script must generate data that fits these exact models.
+
+---
+
+## Project Context
+{{PROJECT_DESCRIPTION}}
+
+## Task Overview
+Generate a **complete, production-ready TypeScript script** that creates {{TOTAL_RECORDS}} realistic records ({{COUNT}} per model) for the dataset `{{DATASOURCE}}-{{DATASET}}`.
+
+### Target Models (READ-ONLY, DO NOT MODIFY)
+{{MODEL_DESCRIPTIONS}}
+
+---
+
+## Script Requirements
+
+### 1. **Data Realism - Top Priority**
+Your generated data MUST be:
+- ✅ **Realistic**: Use appropriate Faker.js methods for each field type and name
+- ✅ **Coherent**: Related fields must make logical sense together
+- ✅ **Domain-appropriate**: Values should reflect real business scenarios
+- ✅ **Diverse**: Include typical values, edge cases, and variations
+
+### 2. **Smart Field Generation**
+Use intelligent generation based on field names and types:
+
+```typescript
+// ❌ BAD: Generic random data
+firstName: faker.lorem.word() // → "dolor"
+
+// ✅ GOOD: Contextual, realistic data  
+firstName: faker.person.firstName() // → "María"
+```
+
+**Field Name Patterns to Handle:**
+- `firstName`, `first_name` → `faker.person.firstName()`
+- `lastName`, `last_name` → `faker.person.lastName()`
+- `email` → `faker.internet.email()`
+- `phone`, `phoneNumber` → `faker.phone.number()`
+- `age` → `faker.number.int({ min: 18, max: 85 })`
+- `company`, `companyName` → `faker.company.name()`
+- `address`, `street` → `faker.location.streetAddress()`
+- `city` → `faker.location.city()`
+- `country` → `faker.location.country()`
+- `zipCode`, `postalCode` → `faker.location.zipCode()`
+- `price`, `amount` → Appropriate range based on context
+- `description` → `faker.lorem.paragraph()` or `faker.commerce.productDescription()`
+- `url`, `website` → `faker.internet.url()`
+- `date`, `createdAt` → `faker.date.past()` or `faker.date.recent()`
+
+### 3. **Field Constraint Compliance**
+Your script MUST respect ALL model constraints:
+- ✅ **Required fields**: Never null/undefined when required
+- ✅ **Length constraints**: Stay within minLength/maxLength bounds
+- ✅ **Numeric ranges**: Respect min/max values
+- ✅ **Regex patterns**: Generate values that match the pattern
+- ✅ **Conditional required/available**: Handle age-dependent fields correctly
+
+### 4. **Relationship Handling**
+For compositions and references:
+- **Compositions**: Generate complete nested objects with all required fields
+- **References**: Reuse previously generated records when possible
+- **Consistency**: Ensure referential integrity across related models
+
+### 5. **Conditional Logic**
+Handle field dependencies correctly:
+
+```typescript
+// Example: parentEmail only required if age < 18
+const age = faker.number.int({ min: 1, max: 90 });
+const person = {
+  age,
+  parentEmail: age < 18 ? faker.internet.email() : undefined,
+  // ... other fields
+};
+```
+
+---
+
+## Script Template
+
+Complete this template with realistic data generation:
+
+```typescript
+/**
+ * Realistic Dataset Generator for {{PROJECT_NAME}}
+ * Dataset: {{DATASOURCE}}-{{DATASET}}
+ * Generated: {{TIMESTAMP}}
+ * 
+ * ⚠️ This script generates synthetic data for testing.
+ * All data must pass model validation constraints.
+ */
+
+import { faker } from '@faker-js/faker';
+import fs from 'fs-extra';
+import path from 'path';
+
+class {{DATASET_CLASS_NAME}}Generator {
+  private outputDir: string;
+
+  constructor() {
+    this.outputDir = path.join(
+      process.cwd(), 
+      'src', 
+      'datasets', 
+      '{{DATASOURCE}}-{{DATASET}}'
+    );
+    
+    // Set seed for reproducible results
+    faker.seed({{SEED}});
+    
+    // Use locale: {{LOCALE}}
+    // faker.locale = '{{LOCALE}}';
+  }
+
+  async generateAll(): Promise<void> {
+    console.log('🎯 Generating {{TOTAL_RECORDS}} realistic records...\n');
+    await fs.ensureDir(this.outputDir);
+    
+    // TODO: Call generation methods in dependency order
+    // Models with no dependencies should be generated first
+    // Example:
+    // await this.generateAddressData();
+    // await this.generatePersonData();
+    
+    console.log('\n🎉 Dataset generation completed successfully!');
+    console.log(`📁 Output: ${this.outputDir}`);
+    console.log('\n💡 Next step: slingr ds {{DATASOURCE}} load {{DATASET}}');
+  }
+
+  // TODO: Implement generation methods for each model
+  // Use the examples below as templates:
+
+  /**
+   * Example generation method - adapt for each model
+   */
+  private async generateExampleData(): Promise<void> {
+    console.log('📝 Generating Example records...');
+    
+    const records = [];
+    for (let i = 0; i < {{COUNT}}; i++) {
+      const record = {
+        // Generate each field with appropriate Faker method
+        // id: faker.string.uuid(), // if not auto-generated
+        // name: faker.person.fullName(),
+        // email: faker.internet.email(),
+        // age: faker.number.int({ min: 18, max: 85 }),
+        // createdAt: faker.date.past().toISOString(),
+        // isActive: faker.datatype.boolean(),
+      };
+      
+      records.push(record);
+    }
+    
+    await this.saveToFile(records, 'Example');
+    console.log(`✅ Generated ${records.length} Example records`);
+  }
+
+  /**
+   * Save records to JSONL file
+   */
+  private async saveToFile<T>(records: T[], modelName: string): Promise<void> {
+    const filePath = path.join(this.outputDir, `${modelName}.jsonl`);
+    const jsonlContent = records.map(r => JSON.stringify(r)).join('\n');
+    await fs.writeFile(filePath, jsonlContent, 'utf-8');
+  }
+}
+
+// Execute if run directly
+if (require.main === module) {
+  new {{DATASET_CLASS_NAME}}Generator()
+    .generateAll()
+    .then(() => {
+      console.log('✨ Success! Dataset is ready to load.');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('❌ Generation failed:', error.message);
+      console.error(error.stack);
+      process.exit(1);
+    });
+}
+
+export { {{DATASET_CLASS_NAME}}Generator };
+```
+
+---
+
+## Your Deliverable
+
+Provide a **complete, runnable TypeScript script** that:
+
+1. ✅ Generates {{COUNT}} realistic records for each of the {{TOTAL_MODELS}} models
+2. ✅ Uses appropriate Faker.js methods based on field names and types
+3. ✅ Respects ALL field constraints (required, min/max, regex, etc.)
+4. ✅ Handles conditional fields correctly (e.g., age-based requirements)
+5. ✅ Creates coherent data where related fields make logical sense
+6. ✅ Maintains referential integrity for relationships
+7. ✅ Includes proper error handling and logging
+8. ✅ Can be executed with: `pnpm run build && node dist/scripts/generate-{{DATASOURCE}}-{{DATASET}}.js`
+
+---
+
+## Quality Checklist
+
+Before providing your script, verify:
+
+- [ ] All model field names are spelled correctly
+- [ ] Each field uses an appropriate Faker.js method
+- [ ] Required fields are never null/undefined
+- [ ] Length and numeric constraints are respected
+- [ ] Conditional logic (age-based, etc.) is implemented
+- [ ] Relationships are handled properly
+- [ ] The script has no syntax errors
+- [ ] All imports are correct
+- [ ] The script is complete and ready to run
+
+---
+
+## Example of Good vs. Bad Data Generation
+
+### ❌ Bad Example (Avoid This):
+```typescript
+{
+  firstName: faker.lorem.word(),           // → "dolor"
+  lastName: faker.lorem.word(),            // → "ipsum" 
+  email: faker.lorem.word(),               // → "sit" (invalid!)
+  age: faker.number.int({ min: 0, max: 200 }), // → 187 (unrealistic)
+  phoneNumber: faker.lorem.word(),         // → "amet" (invalid!)
+}
+```
+
+### ✅ Good Example (Follow This):
+```typescript
+{
+  firstName: faker.person.firstName(),     // → "María"
+  lastName: faker.person.lastName(),       // → "García"
+  email: faker.internet.email(),           // → "maria.garcia@example.com"
+  age: faker.number.int({ min: 18, max: 85 }), // → 34 (realistic)
+  phoneNumber: faker.phone.number(),       // → "+1-234-567-8900"
+}
+```
+
+---
+
+## Technical Details
+- **Framework**: Slingr Framework (TypeScript + TypeORM)
+- **Output Format**: JSONL (one JSON object per line)
+- **Library**: @faker-js/faker (already installed)
+- **Seed**: {{SEED}} (for reproducible results)
+- **Locale**: {{LOCALE}}
+
 **Now provide the complete script that implements realistic data generation for all {{TOTAL_MODELS}} models!**

package/dist/templates/src/Address.ts.template

@@ -1,31 +1,28 @@
-import { Field, Text, Model, BaseModel, Uuid } from 'slingr-framework';
-
-import { {{DATASOURCE_NAME}} } from '../dataSources/{{DATASOURCE_FILE}}';
-
-@Model({ dataSource: {{DATASOURCE_NAME}} })
-export class Address extends BaseModel {
-    @Field({
-        required: true,
-        primaryKey: true,
-    })
-    @Uuid({ generated: true })
-    id!: string;
-
-    @Field({
-        required: true,
-    })
-    @Text({})
-    street!: string;
-
-    @Field({
-        required: true,
-    })
-    @Text({})
-    zipCode!: string;
-
-    @Field({
-        required: true,
-    })
-    @Text({})
-    country!: string;
-}
+import { TextField, DataModel, BaseDataModel, UuidField } from '@slingr/framework-backend';
+
+import { {{DATASOURCE_NAME}} } from '@/dataSources/{{DATASOURCE_FILE}}';
+
+@DataModel({ dataSource: {{DATASOURCE_NAME}} })
+export class Address extends BaseDataModel {
+    @UuidField({
+        required: true,
+        primaryKey: true,
+        generated: true
+    })
+    id!: string;
+
+    @TextField({
+        required: true,
+    })
+    street!: string;
+
+    @TextField({
+        required: true,
+    })
+    zipCode!: string;
+
+    @TextField({
+        required: true,
+    })
+    country!: string;
+}

package/dist/templates/src/App.ts.template

@@ -1,61 +1,17 @@
-import { Field, Text, Model, BaseModel, Reference, Uuid } from "slingr-framework";
-import { Company } from "./Company";
-import { {{DATASOURCE_NAME}} } from "../dataSources/{{DATASOURCE_FILE}}";
-
-@Model({
-    docs: "Represents an application containing info",
-    dataSource: {{DATASOURCE_NAME}}
-})
-export class App extends BaseModel {
-    @Field({
-        required: true,
-        primaryKey: true,
-    })
-    @Uuid(
-        {
-            generated: true
-        }
-    )
-    id!: string;
-
-    @Field({
-        docs: "The name of the application",
-        required: true
-    })
-    @Text({
-        minLength: 4,
-        maxLength: 20,
-        // Regex: allows letters, dots (not at start/end), no underscores, no consecutive dots
-        regex: /^(?!\.)([a-zA-Z]+(\.[a-zA-Z]+)*)?(?<!\.)$/,
-        regexMessage: "Name must contain only letters and dots (no underscores, no consecutive dots, no dot at start/end)",
-    })
-    name!: string;
-
-    @Field({
-        docs: "The version of the application in format AA.BB.CC",
-        required: true
-    })
-    @Text({
-        minLength: 5,
-        maxLength: 8,
-        regex: /^\d{2}\.\d{2}\.\d{2}$/,
-        regexMessage: "Version must be in the format AA.BB.CC, where AA, BB, and CC are two-digit numbers"
-    })
-    version!: string;
-
-    @Field({
-        docs: "The description of the application"
-    })
-    @Text({
-        minLength: 10,
-        maxLength: 500,
-    })
-    description!: string;
-
-    @Field({
-        docs: "The owning company of the application",
-        required: true
-    })
-    @Reference({ load: true, elementType: () => Company })
-    ownerCompany!: Company;
-}
+import { App, BaseApp, logger } from '@slingr/framework-backend';
+import { {{DATASOURCE_NAME}} } from './dataSources/{{DATASOURCE_FILE}}';
+
+@App({ workflowsDataSource: {{DATASOURCE_NAME}} })
+export class {{APP_CLASS_NAME}}App extends BaseApp {
+  override async afterStart(): Promise<void> {
+    logger.info('{{APP_NAME}} started');
+  }
+
+  override async beforeStop(): Promise<void> {
+    logger.info('{{APP_NAME}} stopping');
+  }
+
+  override async onError(error: Error): Promise<void> {
+    logger.error('Unhandled startup error', error);
+  }
+}