@currentjs/gen 0.5.1 → 0.5.2

package/dist/types/configTypes.d.ts

@@ -22,6 +22,11 @@ export interface AggregateFieldConfig {
     unique?: boolean;
     auto?: boolean;
     values?: string[];
+    constraints?: {
+        min?: number;
+        max?: number;
+        pattern?: string;
+    };
 }
 export interface AggregateConfig {
     root?: boolean;

package/dist/utils/migrationUtils.d.ts

@@ -1,16 +1,6 @@
-export interface FieldConfig {
-    name: string;
-    type: string;
-    required?: boolean;
-    unique?: boolean;
-    auto?: boolean;
-}
-export interface ModelConfig {
-    name: string;
-    fields: FieldConfig[];
-}
+import { AggregateConfig, AggregateFieldConfig } from '../types/configTypes';
 export interface SchemaState {
-    models: ModelConfig[];
+    aggregates: Record<string, AggregateConfig>;
     version: string;
     timestamp: string;
 }
@@ -31,19 +21,19 @@ export interface ForeignKeyInfo {
     REFERENCED_TABLE_NAME: string;
     REFERENCED_COLUMN_NAME: string;
 }
-export declare function mapYamlTypeToSql(yamlType: string, availableModels: Set<string>): string;
-export declare function getTableName(modelName: string): string;
+export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>): string;
+export declare function getTableName(aggregateName: string): string;
 export declare function getForeignKeyFieldName(fieldName: string): string;
-export declare function isRelationshipField(fieldType: string, availableModels: Set<string>): boolean;
-export declare function generateCreateTableSQL(model: ModelConfig, availableModels: Set<string>): string;
+export declare function isRelationshipField(fieldType: string, availableAggregates: Set<string>): boolean;
+export declare function generateCreateTableSQL(name: string, aggregate: AggregateConfig, availableAggregates: Set<string>): string;
 export declare function generateDropTableSQL(tableName: string): string;
-export declare function generateAddColumnSQL(tableName: string, field: FieldConfig, availableModels: Set<string>): string;
+export declare function generateAddColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>): string;
 export declare function generateDropColumnSQL(tableName: string, columnName: string): string;
-export declare function generateModifyColumnSQL(tableName: string, field: FieldConfig, availableModels: Set<string>): string;
+export declare function generateModifyColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>): string;
 export declare function loadSchemaState(stateFilePath: string): SchemaState | null;
 export declare function saveSchemaState(stateFilePath: string, state: SchemaState): void;
 export declare function loadMigrationLog(logFilePath: string): MigrationLog;
 export declare function saveMigrationLog(logFilePath: string, log: MigrationLog): void;
-export declare function compareSchemas(oldState: SchemaState | null, newModels: ModelConfig[]): string[];
+export declare function compareSchemas(oldState: SchemaState | null, newAggregates: Record<string, AggregateConfig>): string[];
 export declare function generateTimestamp(): string;
 export declare function getMigrationFileName(timestamp: string): string;

package/dist/utils/migrationUtils.js

@@ -61,39 +61,33 @@ const TYPE_MAPPING = {
     array: 'JSON',
     object: 'JSON'
 };
-function mapYamlTypeToSql(yamlType, availableModels) {
-    // Check if this is a relationship (foreign key)
-    if (availableModels.has(yamlType)) {
-        return 'INT'; // Foreign keys are INT
+function mapYamlTypeToSql(yamlType, availableAggregates) {
+    if (availableAggregates.has(yamlType)) {
+        return 'INT';
     }
     return TYPE_MAPPING[yamlType] || 'VARCHAR(255)';
 }
-function getTableName(modelName) {
-    return modelName.toLowerCase() + 's';
+function getTableName(aggregateName) {
+    return aggregateName.toLowerCase() + 's';
 }
 function getForeignKeyFieldName(fieldName) {
     return fieldName + 'Id';
 }
-function isRelationshipField(fieldType, availableModels) {
-    return availableModels.has(fieldType);
+function isRelationshipField(fieldType, availableAggregates) {
+    return availableAggregates.has(fieldType);
 }
-function generateCreateTableSQL(model, availableModels) {
-    const tableName = getTableName(model.name);
+function generateCreateTableSQL(name, aggregate, availableAggregates) {
+    const tableName = getTableName(name);
     const columns = [];
     const indexes = [];
     const foreignKeys = [];
-    // Add id column
     columns.push('  id INT AUTO_INCREMENT PRIMARY KEY');
-    // Add model fields
-    model.fields.forEach(field => {
-        if (isRelationshipField(field.type, availableModels)) {
-            // Foreign key field
-            const foreignKeyName = getForeignKeyFieldName(field.name);
+    for (const [fieldName, field] of Object.entries(aggregate.fields)) {
+        if (isRelationshipField(field.type, availableAggregates)) {
+            const foreignKeyName = getForeignKeyFieldName(fieldName);
             const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
             columns.push(`  ${foreignKeyName} INT ${nullable}`);
-            // Add index for foreign key
             indexes.push(`  INDEX idx_${tableName}_${foreignKeyName} (${foreignKeyName})`);
-            // Add foreign key constraint
             const refTableName = getTableName(field.type);
             foreignKeys.push(`  CONSTRAINT fk_${tableName}_${foreignKeyName} \n` +
                 `    FOREIGN KEY (${foreignKeyName}) \n` +
@@ -102,58 +96,50 @@ function generateCreateTableSQL(model, availableModels) {
                 `    ON UPDATE CASCADE`);
         }
         else {
-            // Regular field
-            const sqlType = mapYamlTypeToSql(field.type, availableModels);
+            const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
             const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-            columns.push(`  ${field.name} ${sqlType} ${nullable}`);
-            // Add index for filterable fields
+            columns.push(`  ${fieldName} ${sqlType} ${nullable}`);
             if (['string', 'number'].includes(field.type)) {
-                indexes.push(`  INDEX idx_${tableName}_${field.name} (${field.name})`);
+                indexes.push(`  INDEX idx_${tableName}_${fieldName} (${fieldName})`);
             }
         }
-    });
-    // Add standard timestamp columns
+    }
     columns.push('  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP');
     columns.push('  updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
     columns.push('  deleted_at DATETIME NULL DEFAULT NULL');
-    // Add standard indexes
     indexes.push(`  INDEX idx_${tableName}_deleted_at (deleted_at)`);
     indexes.push(`  INDEX idx_${tableName}_created_at (created_at)`);
-    // Combine all parts
     const allParts = [...columns, ...indexes, ...foreignKeys];
-    const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
-    return sql;
+    return `CREATE TABLE IF NOT EXISTS ${tableName} (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
 }
 function generateDropTableSQL(tableName) {
     return `DROP TABLE IF EXISTS ${tableName};`;
 }
-function generateAddColumnSQL(tableName, field, availableModels) {
-    if (isRelationshipField(field.type, availableModels)) {
-        const foreignKeyName = getForeignKeyFieldName(field.name);
+function generateAddColumnSQL(tableName, fieldName, field, availableAggregates) {
+    if (isRelationshipField(field.type, availableAggregates)) {
+        const foreignKeyName = getForeignKeyFieldName(fieldName);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        const sqlType = 'INT';
-        return `ALTER TABLE ${tableName} ADD COLUMN ${foreignKeyName} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} ADD COLUMN ${foreignKeyName} INT ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableModels);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} ADD COLUMN ${field.name} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${sqlType} ${nullable};`;
     }
 }
 function generateDropColumnSQL(tableName, columnName) {
     return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
 }
-function generateModifyColumnSQL(tableName, field, availableModels) {
-    if (isRelationshipField(field.type, availableModels)) {
-        const foreignKeyName = getForeignKeyFieldName(field.name);
+function generateModifyColumnSQL(tableName, fieldName, field, availableAggregates) {
+    if (isRelationshipField(field.type, availableAggregates)) {
+        const foreignKeyName = getForeignKeyFieldName(fieldName);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        const sqlType = 'INT';
-        return `ALTER TABLE ${tableName} MODIFY COLUMN ${foreignKeyName} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} MODIFY COLUMN ${foreignKeyName} INT ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableModels);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} MODIFY COLUMN ${field.name} ${sqlType} ${nullable};`;
+        return `ALTER TABLE ${tableName} MODIFY COLUMN ${fieldName} ${sqlType} ${nullable};`;
     }
 }
 function loadSchemaState(stateFilePath) {
@@ -178,109 +164,93 @@ function saveMigrationLog(logFilePath, log) {
     fs.mkdirSync(path.dirname(logFilePath), { recursive: true });
     fs.writeFileSync(logFilePath, JSON.stringify(log, null, 2));
 }
-/**
- * Sort models by dependencies so tables are created in the right order
- * (tables with no foreign keys first, then tables that depend on them)
- */
-function sortModelsByDependencies(models, availableModels) {
+function sortAggregatesByDependencies(aggregates, availableAggregates) {
     const sorted = [];
     const processed = new Set();
-    const addModel = (model) => {
-        if (processed.has(model.name))
+    const addAggregate = (name, aggregate) => {
+        if (processed.has(name))
             return;
-        // Find foreign key dependencies
-        const dependencies = [];
-        model.fields.forEach(field => {
-            if (isRelationshipField(field.type, availableModels)) {
-                dependencies.push(field.type);
-            }
-        });
-        // Add dependencies first
-        dependencies.forEach(depName => {
-            const depModel = models.find(m => m.name === depName);
-            if (depModel && !processed.has(depName)) {
-                addModel(depModel);
+        for (const [, field] of Object.entries(aggregate.fields)) {
+            if (isRelationshipField(field.type, availableAggregates)) {
+                const dep = aggregates[field.type];
+                if (dep && !processed.has(field.type)) {
+                    addAggregate(field.type, dep);
+                }
             }
-        });
-        // Then add this model
-        sorted.push(model);
-        processed.add(model.name);
+        }
+        sorted.push([name, aggregate]);
+        processed.add(name);
     };
-    models.forEach(model => addModel(model));
+    for (const [name, aggregate] of Object.entries(aggregates)) {
+        addAggregate(name, aggregate);
+    }
     return sorted;
 }
-function compareSchemas(oldState, newModels) {
+function compareSchemas(oldState, newAggregates) {
     const sqlStatements = [];
-    const availableModels = new Set(newModels.map(m => m.name));
-    if (!oldState || oldState.models.length === 0) {
-        // No previous state - generate all CREATE TABLE statements in dependency order
-        const sortedModels = sortModelsByDependencies(newModels, availableModels);
-        sortedModels.forEach(model => {
-            sqlStatements.push(`-- Create ${model.name.toLowerCase()}s table`);
-            sqlStatements.push(generateCreateTableSQL(model, availableModels));
+    const availableAggregates = new Set(Object.keys(newAggregates));
+    if (!oldState || !oldState.aggregates || Object.keys(oldState.aggregates).length === 0) {
+        const sorted = sortAggregatesByDependencies(newAggregates, availableAggregates);
+        for (const [name, aggregate] of sorted) {
+            sqlStatements.push(`-- Create ${name.toLowerCase()}s table`);
+            sqlStatements.push(generateCreateTableSQL(name, aggregate, availableAggregates));
             sqlStatements.push('');
-        });
+        }
         return sqlStatements;
     }
-    // Create maps for easy lookup
-    const oldModelsMap = new Map(oldState.models.map(m => [m.name, m]));
-    const newModelsMap = new Map(newModels.map(m => [m.name, m]));
+    const oldAggregates = oldState.aggregates;
     // Find dropped tables
-    oldState.models.forEach(oldModel => {
-        if (!newModelsMap.has(oldModel.name)) {
-            const tableName = getTableName(oldModel.name);
+    for (const oldName of Object.keys(oldAggregates)) {
+        if (!newAggregates[oldName]) {
+            const tableName = getTableName(oldName);
             sqlStatements.push(`-- Drop ${tableName} table`);
             sqlStatements.push(generateDropTableSQL(tableName));
             sqlStatements.push('');
         }
-    });
-    // Find new tables and modified tables
-    newModels.forEach(newModel => {
-        const oldModel = oldModelsMap.get(newModel.name);
-        const tableName = getTableName(newModel.name);
-        if (!oldModel) {
-            // New table
+    }
+    // Find new and modified tables
+    for (const [name, newAggregate] of Object.entries(newAggregates)) {
+        const oldAggregate = oldAggregates[name];
+        const tableName = getTableName(name);
+        if (!oldAggregate) {
             sqlStatements.push(`-- Create ${tableName} table`);
-            sqlStatements.push(generateCreateTableSQL(newModel, availableModels));
+            sqlStatements.push(generateCreateTableSQL(name, newAggregate, availableAggregates));
             sqlStatements.push('');
         }
         else {
-            // Table exists - check for column changes
-            const oldFieldsMap = new Map(oldModel.fields.map(f => [f.name, f]));
-            const newFieldsMap = new Map(newModel.fields.map(f => [f.name, f]));
+            const oldFields = oldAggregate.fields;
+            const newFields = newAggregate.fields;
             // Find dropped columns
-            oldModel.fields.forEach(oldField => {
-                if (!newFieldsMap.has(oldField.name)) {
-                    const columnName = isRelationshipField(oldField.type, availableModels)
-                        ? getForeignKeyFieldName(oldField.name)
-                        : oldField.name;
+            for (const oldFieldName of Object.keys(oldFields)) {
+                if (!newFields[oldFieldName]) {
+                    const columnName = isRelationshipField(oldFields[oldFieldName].type, availableAggregates)
+                        ? getForeignKeyFieldName(oldFieldName)
+                        : oldFieldName;
                     sqlStatements.push(`-- Drop column ${columnName} from ${tableName}`);
                     sqlStatements.push(generateDropColumnSQL(tableName, columnName));
                     sqlStatements.push('');
                 }
-            });
-            // Find new columns and modified columns
-            newModel.fields.forEach(newField => {
-                const oldField = oldFieldsMap.get(newField.name);
+            }
+            // Find new and modified columns
+            for (const [fieldName, newField] of Object.entries(newFields)) {
+                const oldField = oldFields[fieldName];
                 if (!oldField) {
-                    // New column
-                    sqlStatements.push(`-- Add column ${newField.name} to ${tableName}`);
-                    sqlStatements.push(generateAddColumnSQL(tableName, newField, availableModels));
+                    sqlStatements.push(`-- Add column ${fieldName} to ${tableName}`);
+                    sqlStatements.push(generateAddColumnSQL(tableName, fieldName, newField, availableAggregates));
                     sqlStatements.push('');
                 }
                 else {
-                    // Check if column definition changed
                     const typeChanged = oldField.type !== newField.type;
                     const requiredChanged = oldField.required !== newField.required;
                     if (typeChanged || requiredChanged) {
-                        sqlStatements.push(`-- Modify column ${newField.name} in ${tableName}`);
-                        sqlStatements.push(generateModifyColumnSQL(tableName, newField, availableModels));
+                        sqlStatements.push(`-- Modify column ${fieldName} in ${tableName}`);
+                        sqlStatements.push(generateModifyColumnSQL(tableName, fieldName, newField, availableAggregates));
                         sqlStatements.push('');
                     }
                 }
-            });
+            }
         }
-    });
+    }
     return sqlStatements;
 }
 function generateTimestamp() {

package/dist/utils/promptUtils.d.ts

@@ -0,0 +1,37 @@
+import * as readline from 'readline';
+export declare function createRl(): readline.Interface;
+/**
+ * Ask for free-form text.
+ * If allowEmpty is false (default), re-prompts until non-blank is entered.
+ */
+export declare function promptText(rl: readline.Interface, question: string, opts?: {
+    allowEmpty?: boolean;
+    defaultValue?: string;
+}): Promise<string>;
+/**
+ * Ask for a number. Re-prompts on invalid input.
+ */
+export declare function promptNumber(rl: readline.Interface, question: string, defaultValue?: number): Promise<number | undefined>;
+/**
+ * Yes/No prompt. Returns true for yes.
+ */
+export declare function promptYesNo(rl: readline.Interface, question: string, defaultYes?: boolean): Promise<boolean>;
+/**
+ * Single-select from a list of choices. Returns the chosen item.
+ */
+export declare function promptSelect<T extends {
+    label: string;
+    value: string;
+}>(rl: readline.Interface, question: string, choices: T[]): Promise<T>;
+/**
+ * Multi-select from a list of choices.
+ * User types comma-separated numbers, "all", or "none".
+ * Returns array of selected items (may be empty).
+ */
+export declare function promptMultiSelect<T extends {
+    label: string;
+    value: string;
+}>(rl: readline.Interface, question: string, choices: T[], opts?: {
+    allowNone?: boolean;
+    defaultAll?: boolean;
+}): Promise<T[]>;

package/dist/utils/promptUtils.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRl = createRl;
+exports.promptText = promptText;
+exports.promptNumber = promptNumber;
+exports.promptYesNo = promptYesNo;
+exports.promptSelect = promptSelect;
+exports.promptMultiSelect = promptMultiSelect;
+const readline = __importStar(require("readline"));
+const colors_1 = require("./colors");
+function createRl() {
+    return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+function ask(rl, question) {
+    return new Promise(resolve => rl.question(question, resolve));
+}
+/**
+ * Ask for free-form text.
+ * If allowEmpty is false (default), re-prompts until non-blank is entered.
+ */
+async function promptText(rl, question, opts = {}) {
+    const { allowEmpty = false, defaultValue } = opts;
+    const suffix = defaultValue !== undefined ? colors_1.colors.gray(` (${defaultValue})`) : '';
+    while (true) {
+        const raw = await ask(rl, `${question}${suffix} `);
+        const value = raw.trim();
+        if (value !== '')
+            return value;
+        if (allowEmpty)
+            return defaultValue !== null && defaultValue !== void 0 ? defaultValue : '';
+        console.log(colors_1.colors.yellow('  Value is required. Please enter something.'));
+    }
+}
+/**
+ * Ask for a number. Re-prompts on invalid input.
+ */
+async function promptNumber(rl, question, defaultValue) {
+    const suffix = defaultValue !== undefined ? colors_1.colors.gray(` (${defaultValue})`) : colors_1.colors.gray(' (leave blank to skip)');
+    const raw = await ask(rl, `${question}${suffix} `);
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return defaultValue;
+    const n = Number(trimmed);
+    if (isNaN(n)) {
+        console.log(colors_1.colors.yellow('  Invalid number, skipping.'));
+        return undefined;
+    }
+    return n;
+}
+/**
+ * Yes/No prompt. Returns true for yes.
+ */
+async function promptYesNo(rl, question, defaultYes = true) {
+    const hint = defaultYes ? colors_1.colors.gray('[Y/n]') : colors_1.colors.gray('[y/N]');
+    const raw = await ask(rl, `${question} ${hint} `);
+    const trimmed = raw.trim().toLowerCase();
+    if (trimmed === '')
+        return defaultYes;
+    return trimmed === 'y' || trimmed === 'yes';
+}
+/**
+ * Single-select from a list of choices. Returns the chosen item.
+ */
+async function promptSelect(rl, question, choices) {
+    console.log(colors_1.colors.bold(question));
+    choices.forEach((c, i) => {
+        console.log(`  ${colors_1.colors.cyan(String(i + 1).padStart(2))}. ${c.label}`);
+    });
+    while (true) {
+        const raw = await ask(rl, `  ${colors_1.colors.gray('Enter number:')} `);
+        const n = parseInt(raw.trim(), 10);
+        if (!isNaN(n) && n >= 1 && n <= choices.length) {
+            return choices[n - 1];
+        }
+        console.log(colors_1.colors.yellow(`  Please enter a number between 1 and ${choices.length}.`));
+    }
+}
+/**
+ * Multi-select from a list of choices.
+ * User types comma-separated numbers, "all", or "none".
+ * Returns array of selected items (may be empty).
+ */
+async function promptMultiSelect(rl, question, choices, opts = {}) {
+    const { allowNone = true, defaultAll = false } = opts;
+    console.log(colors_1.colors.bold(question));
+    choices.forEach((c, i) => {
+        console.log(`  ${colors_1.colors.cyan(String(i + 1).padStart(2))}. ${c.label}`);
+    });
+    const hint = defaultAll ? colors_1.colors.gray('(comma-separated, "all", or "none" – default: all)') : colors_1.colors.gray('(comma-separated, "all", or "none")');
+    while (true) {
+        const raw = await ask(rl, `  ${hint} `);
+        const trimmed = raw.trim().toLowerCase();
+        if (trimmed === '' && defaultAll)
+            return [...choices];
+        if (trimmed === 'all')
+            return [...choices];
+        if (trimmed === 'none') {
+            if (allowNone)
+                return [];
+            console.log(colors_1.colors.yellow('  At least one selection is required.'));
+            continue;
+        }
+        const parts = trimmed.split(',').map(s => s.trim()).filter(Boolean);
+        const indices = parts.map(p => parseInt(p, 10));
+        if (indices.some(n => isNaN(n) || n < 1 || n > choices.length)) {
+            console.log(colors_1.colors.yellow(`  Please enter numbers between 1 and ${choices.length}, "all", or "none".`));
+            continue;
+        }
+        const selected = [...new Set(indices)].map(n => choices[n - 1]);
+        if (selected.length === 0 && !allowNone) {
+            console.log(colors_1.colors.yellow('  At least one selection is required.'));
+            continue;
+        }
+        return selected;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@currentjs/gen",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",

package/dist/commands/createApp.d.ts

@@ -1 +0,0 @@
-export declare function handleCreateApp(rawName?: string): void;