generate-ui-cli 2.1.7 → 2.3.0

package/dist/generators/angular/menu.generator.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMenu = generateMenu;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function generateMenu(schemasRoot) {
+    const menu = loadMenuConfig(schemasRoot) ??
+        buildMenuFromRoutes(loadRoutesConfig(schemasRoot)) ?? {
+        groups: [],
+        ungrouped: []
+    };
+    const out = path_1.default.join(schemasRoot, 'menu.gen.ts');
+    const content = `
+export type GeneratedMenuItem = {
+  id: string
+  label: string
+  route: string
+  hidden?: boolean
+  icon?: string
+}
+
+export type GeneratedMenuGroup = {
+  id: string
+  label: string
+  items: GeneratedMenuItem[]
+  hidden?: boolean
+}
+
+export type GeneratedMenu = {
+  groups: GeneratedMenuGroup[]
+  ungrouped: GeneratedMenuItem[]
+}
+
+export const generatedMenu: GeneratedMenu = ${JSON.stringify(normalizeMenu(menu), null, 2)}
+`;
+    fs_1.default.writeFileSync(out, content.trimStart());
+}
+function loadMenuConfig(schemasRoot) {
+    const overridePath = path_1.default.join(schemasRoot, 'menu.overrides.json');
+    const basePath = path_1.default.join(schemasRoot, 'menu.json');
+    if (fs_1.default.existsSync(overridePath)) {
+        const override = JSON.parse(fs_1.default.readFileSync(overridePath, 'utf-8'));
+        const hasOverride = Array.isArray(override?.groups) &&
+            override.groups.length > 0
+            ? true
+            : Array.isArray(override?.ungrouped) &&
+                override.ungrouped.length > 0;
+        if (hasOverride) {
+            return override;
+        }
+    }
+    if (fs_1.default.existsSync(basePath)) {
+        return JSON.parse(fs_1.default.readFileSync(basePath, 'utf-8'));
+    }
+    return null;
+}
+function loadRoutesConfig(schemasRoot) {
+    const routesPath = path_1.default.join(schemasRoot, 'routes.json');
+    if (!fs_1.default.existsSync(routesPath))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(routesPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeMenu(value) {
+    return {
+        groups: Array.isArray(value?.groups)
+            ? value.groups.map(normalizeGroup)
+            : [],
+        ungrouped: Array.isArray(value?.ungrouped)
+            ? value.ungrouped.map(normalizeItem)
+            : []
+    };
+}
+function normalizeGroup(value) {
+    return {
+        id: String(value?.id ?? ''),
+        label: String(value?.label ?? ''),
+        hidden: Boolean(value?.hidden) || undefined,
+        items: Array.isArray(value?.items)
+            ? value.items.map(normalizeItem)
+            : []
+    };
+}
+function normalizeItem(value) {
+    return {
+        id: String(value?.id ?? ''),
+        label: String(value?.label ?? ''),
+        route: String(value?.route ?? ''),
+        hidden: Boolean(value?.hidden) || undefined,
+        icon: value?.icon ? String(value.icon) : undefined
+    };
+}
+function buildMenuFromRoutes(routes) {
+    if (!Array.isArray(routes) || routes.length === 0)
+        return null;
+    const groups = [];
+    const ungrouped = [];
+    const groupMap = new Map();
+    for (const route of routes) {
+        if (!route?.path || !route?.operationId)
+            continue;
+        const item = {
+            id: String(route.operationId),
+            label: toLabel(String(route.label ?? route.operationId)),
+            route: normalizeRoutePath(String(route.path ?? route.operationId ?? ''))
+        };
+        const rawGroup = route.group ? String(route.group) : '';
+        if (!rawGroup) {
+            ungrouped.push(item);
+            continue;
+        }
+        const groupId = toKebab(rawGroup);
+        let group = groupMap.get(groupId);
+        if (!group) {
+            group = {
+                id: groupId,
+                label: toLabel(rawGroup),
+                items: []
+            };
+            groupMap.set(groupId, group);
+            groups.push(group);
+        }
+        group.items.push(item);
+    }
+    return { groups, ungrouped };
+}
+function toKebab(value) {
+    return String(value)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[_\\s]+/g, '-')
+        .toLowerCase();
+}
+function toLabel(value) {
+    return String(value)
+        .replace(/[_-]/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/\\b\\w/g, char => char.toUpperCase());
+}
+function normalizeRoutePath(value) {
+    if (!value)
+        return value;
+    if (value.includes('/'))
+        return value.replace(/^\//, '');
+    const pascal = toPascalCase(value);
+    return toRouteSegment(pascal);
+}
+function toRouteSegment(value) {
+    if (!value)
+        return value;
+    return value[0].toLowerCase() + value.slice(1);
+}
+function toPascalCase(value) {
+    return String(value)
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(part => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}

package/dist/generators/angular/routes.generator.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRoutes = generateRoutes;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-function generateRoutes(routes, featuresRoot, schemasRoot) {
+function generateRoutes(routes, generatedRoot, overridesRoot, schemasRoot) {
     const out = path_1.default.join(schemasRoot, 'routes.gen.ts');
-    const featuresImportBase = buildRelativeImportBase(schemasRoot, featuresRoot);
+    const generatedImportBase = buildRelativeImportBase(schemasRoot, generatedRoot);
+    const overridesImportBase = buildRelativeImportBase(schemasRoot, overridesRoot);
     fs_1.default.mkdirSync(path_1.default.dirname(out), { recursive: true });
     const content = `
 import { Routes } from '@angular/router'
@@ -16,7 +17,11 @@ import { Routes } from '@angular/router'
 export const generatedRoutes: Routes = [
 ${routes
         .flatMap(r => {
-        const baseImport = ensureRelativeImport(toPosixPath(path_1.default.join(featuresImportBase, r.folder, `${r.fileBase}.component`)));
+        const overridePath = path_1.default.join(overridesRoot, r.folder, `${r.fileBase}.component.ts`);
+        const importBase = fs_1.default.existsSync(overridePath)
+            ? overridesImportBase
+            : generatedImportBase;
+        const baseImport = ensureRelativeImport(toPosixPath(path_1.default.join(importBase, r.folder, `${r.fileBase}.component`)));
         const base = `  {
     path: '${r.path}',
     loadComponent: () =>

package/dist/generators/screen.generator.js

@@ -19,13 +19,13 @@ function inferScreen(method, hasInput) {
 }
 function inferActions(method, hasInput) {
     if (method === 'get' && hasInput) {
-        return { primary: { type: 'submit', label: 'Buscar' } };
+        return { primary: { type: 'submit', label: 'Search' } };
     }
     if (method === 'post') {
-        return { primary: { type: 'submit', label: 'Criar' } };
+        return { primary: { type: 'submit', label: 'Create' } };
     }
     if (method === 'put' || method === 'patch') {
-        return { primary: { type: 'submit', label: 'Salvar' } };
+        return { primary: { type: 'submit', label: 'Save' } };
     }
     return {};
 }
@@ -49,6 +49,15 @@ function generateScreen(endpoint, api) {
         pathParams.length > 0;
     const openapiVersion = api?.info?.version || 'unknown';
     const screenMeta = buildMeta(endpoint.operationId, 'api', openapiVersion);
+    const columnKeys = method === 'get'
+        ? inferResponseColumns(endpoint)
+        : [];
+    const responseFormat = inferResponseFormat(endpoint);
+    const columns = columnKeys.map(key => ({
+        key,
+        label: toLabel(key),
+        visible: true
+    }));
     return {
         meta: screenMeta,
         entity: endpoint.summary
@@ -70,9 +79,90 @@ function generateScreen(endpoint, api) {
         layout: { type: 'single' },
         fields: decorateFields(fields, 'body', openapiVersion),
         actions: inferActions(method, hasInput),
-        data: {}
+        response: responseFormat
+            ? { format: responseFormat }
+            : undefined,
+        data: {
+            table: {
+                columns
+            }
+        }
     };
 }
+function inferResponseColumns(endpoint) {
+    const schema = getPrimaryResponseSchema(endpoint);
+    if (!schema)
+        return [];
+    return inferColumnsFromSchema(schema);
+}
+function inferResponseFormat(endpoint) {
+    const schema = getPrimaryResponseSchema(endpoint);
+    if (!schema)
+        return null;
+    if (!hasResponseData(schema))
+        return null;
+    return 'table';
+}
+function getPrimaryResponseSchema(endpoint) {
+    const responses = endpoint?.responses ?? {};
+    const candidate = responses['200'] ||
+        responses['201'] ||
+        responses.default ||
+        Object.values(responses)[0];
+    return candidate?.content?.['application/json']?.schema ?? null;
+}
+function hasResponseData(schema) {
+    if (!schema)
+        return false;
+    if (Array.isArray(schema.allOf)) {
+        return schema.allOf.some((entry) => hasResponseData(entry));
+    }
+    if (Array.isArray(schema.anyOf)) {
+        return schema.anyOf.some((entry) => hasResponseData(entry));
+    }
+    if (Array.isArray(schema.oneOf)) {
+        return schema.oneOf.some((entry) => hasResponseData(entry));
+    }
+    if (schema.type === 'array')
+        return true;
+    if (schema.type === 'object' &&
+        (schema.properties || schema.additionalProperties)) {
+        return true;
+    }
+    return inferColumnsFromSchema(schema).length > 0;
+}
+function inferColumnsFromSchema(schema) {
+    if (!schema)
+        return [];
+    if (Array.isArray(schema.allOf)) {
+        for (const entry of schema.allOf) {
+            const columns = inferColumnsFromSchema(entry);
+            if (columns.length)
+                return columns;
+        }
+    }
+    if (schema.type === 'array') {
+        return inferColumnsFromSchema(schema.items);
+    }
+    if (schema.type === 'object' && schema.properties) {
+        const commonKeys = [
+            'data',
+            'items',
+            'results',
+            'list',
+            'records',
+            'products'
+        ];
+        for (const key of commonKeys) {
+            const nested = schema.properties[key];
+            const columns = inferColumnsFromSchema(nested);
+            if (columns.length)
+                return columns;
+        }
+        return Object.keys(schema.properties);
+    }
+    return [];
+}
 function extractQueryParams(endpoint, api) {
     const params = endpoint?.parameters ?? [];
     return params
@@ -110,11 +200,16 @@ function extractPathParams(path, api) {
     }));
 }
 function toLabel(value) {
-    return String(value)
+    return stripDiacritics(String(value))
         .replace(/[_-]/g, ' ')
         .replace(/([a-z])([A-Z])/g, '$1 $2')
         .replace(/\b\w/g, char => char.toUpperCase());
 }
+function stripDiacritics(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '');
+}
 function buildMeta(id, source, openapiVersion) {
     return {
         id,

package/dist/generators/screen.merge.js

@@ -10,6 +10,10 @@ const PRESENTATION_KEYS = [
     'group',
     'hidden'
 ];
+const COLUMN_PRESENTATION_KEYS = [
+    'label',
+    'visible'
+];
 function mergeScreen(nextScreen, overlay, prevGenerated, options) {
     const debug = [];
     if (!overlay) {
@@ -25,7 +29,9 @@ function mergeScreen(nextScreen, overlay, prevGenerated, options) {
         entity: normalizedOverlay.entity ?? normalizedNext.entity,
         screen: normalizedOverlay.screen ?? normalizedNext.screen,
         layout: normalizedOverlay.layout ?? normalizedNext.layout,
-        actions: mergeActions(normalizedNext.actions, normalizedOverlay.actions)
+        actions: mergeActions(normalizedNext.actions, normalizedOverlay.actions),
+        response: mergeResponse(normalizedNext.response, normalizedOverlay.response),
+        data: mergeData(normalizedNext.data, normalizedOverlay.data)
     };
     merged.api = {
         ...normalizedNext.api,
@@ -46,6 +52,62 @@ function mergeActions(nextActions, overlayActions) {
     }
     return merged;
 }
+function mergeResponse(nextResponse, overlayResponse) {
+    if (!overlayResponse)
+        return nextResponse;
+    const allowed = ['table', 'cards', 'raw'];
+    const candidate = String(overlayResponse?.format || '')
+        .trim()
+        .toLowerCase();
+    if (!allowed.includes(candidate))
+        return nextResponse;
+    return {
+        ...(nextResponse || {}),
+        format: candidate
+    };
+}
+function mergeData(nextData, overlayData) {
+    const nextColumns = nextData?.table?.columns;
+    const overlayColumns = overlayData?.table?.columns;
+    if (!Array.isArray(nextColumns)) {
+        return nextData ?? {};
+    }
+    const overlayMap = new Map();
+    if (Array.isArray(overlayColumns)) {
+        for (const entry of overlayColumns) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const key = String(entry.key ?? entry.id ?? entry.column ?? '').trim();
+            if (!key)
+                continue;
+            overlayMap.set(key, entry);
+        }
+    }
+    const mergedColumns = nextColumns.map((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return entry;
+        const key = String(entry.key ?? entry.id ?? entry.column ?? '').trim();
+        if (!key)
+            return entry;
+        const overlay = overlayMap.get(key);
+        if (!overlay)
+            return entry;
+        const merged = { ...entry };
+        for (const prop of COLUMN_PRESENTATION_KEYS) {
+            if (overlay[prop] !== undefined) {
+                merged[prop] = overlay[prop];
+            }
+        }
+        return merged;
+    });
+    return {
+        ...(nextData || {}),
+        table: {
+            ...(nextData?.table || {}),
+            columns: mergedColumns
+        }
+    };
+}
 function mergeFieldList(nextFields, overlayFields, prevFields, options, debug, scope) {
     const nextMap = indexById(nextFields, scope);
     const overlayMap = indexById(overlayFields, scope);
@@ -80,20 +142,6 @@ function mergeFieldList(nextFields, overlayFields, prevFields, options, debug, s
     for (const [id, nextField] of nextMap.entries()) {
         if (used.has(id))
             continue;
-        const prevField = prevMap.get(id);
-        if (prevField && !overlayMap.has(id)) {
-            result.push({
-                ...nextField,
-                hidden: true,
-                meta: {
-                    ...mergeMeta(nextField.meta, prevField.meta, options.openapiVersion),
-                    userRemoved: true,
-                    lastChangedBy: 'user'
-                }
-            });
-            debug.push(`USER_REMOVED_TOMBSTONE ${id}`);
-            continue;
-        }
         const autoAdded = !nextField.required;
         result.push({
             ...nextField,
@@ -127,6 +175,13 @@ function mergeField(nextField, overlayField, prevField, options, debug) {
     if (prevField && prevField.type !== nextField.type) {
         merged.ui = undefined;
         merged.options = nextField.options ?? null;
+        merged.defaultValue = nextField.defaultValue;
+        merged.hidden = nextField.hidden;
+        merged.meta = {
+            ...meta,
+            userRemoved: false,
+            lastChangedBy: 'api'
+        };
         debug.push(`TYPE_CHANGED ${meta.id}`);
     }
     const prevEnum = Array.isArray(prevField?.options);

package/dist/index.js

@@ -5,25 +5,62 @@ const commander_1 = require("commander");
 const generate_1 = require("./commands/generate");
 const angular_1 = require("./commands/angular");
 const login_1 = require("./commands/login");
+const merge_1 = require("./commands/merge");
 const config_1 = require("./runtime/config");
 const telemetry_1 = require("./telemetry");
+const logger_1 = require("./runtime/logger");
 const program = new commander_1.Command();
 program
     .name('generate-ui')
     .description('Generate UI from OpenAPI')
     .version((0, config_1.getCliVersion)())
-    .option('--no-telemetry', 'Disable telemetry');
+    .option('--no-telemetry', 'Disable telemetry')
+    .option('--dev', 'Enable verbose logs')
+    .option('--verbose', 'Enable verbose logs (same as --dev)');
 /**
- * 1️⃣ OpenAPI → Screen schemas
+ * 1️⃣ Default flow: OpenAPI → Schemas → Angular
  */
 program
     .command('generate')
-    .description('Generate screen schemas from OpenAPI')
-    .requiredOption('-o, --openapi <path>', 'OpenAPI file')
-    .option('--output <path>', 'Output directory for generate-ui (default: ./src/generate-ui or ./generate-ui)')
+    .description('Generate schemas and Angular code (default flow)')
+    .option('-o, --openapi <path>', 'OpenAPI file (optional if configured in generateui-config.json)')
+    .option('--output <path>', 'Output directory for generate-ui (optional if configured in generateui-config.json)')
+    .option('-f, --features <path>', 'Angular features output directory (optional if configured in generateui-config.json)')
+    .option('-w, --watch', 'Keep watching .screen.json files after generation')
     .option('-d, --debug', 'Explain merge decisions')
     .action(async (options) => {
-    const { telemetry } = program.opts();
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
+    try {
+        await (0, telemetry_1.trackGenerateCalled)();
+        await (0, generate_1.generate)({
+            openapi: options.openapi,
+            output: options.output,
+            debug: options.debug,
+            telemetryEnabled: telemetry
+        });
+        await (0, angular_1.angular)({
+            featuresPath: options.features,
+            watch: Boolean(options.watch),
+            telemetryEnabled: telemetry
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+/**
+ * 2️⃣ Advanced: OpenAPI → Screen schemas only
+ */
+program
+    .command('schema')
+    .description('Advanced: generate screen schemas only')
+    .option('-o, --openapi <path>', 'OpenAPI file (optional if configured in generateui-config.json)')
+    .option('--output <path>', 'Output directory for generate-ui (optional if configured in generateui-config.json)')
+    .option('-d, --debug', 'Explain merge decisions')
+    .action(async (options) => {
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
     try {
         await (0, telemetry_1.trackGenerateCalled)();
         await (0, generate_1.generate)({
@@ -38,19 +75,23 @@ program
     }
 });
 /**
- * 2️⃣ Screen schemas → Angular code
+ * 3️⃣ Advanced: Screen schemas → Angular code
  */
 program
     .command('angular')
-    .description('Generate Angular code from screen schemas')
+    .description('Advanced: generate Angular code from screen schemas')
     .option('-s, --schemas <path>', 'Directory containing generate-ui (with overlays/)')
-    .option('-f, --features <path>', 'Angular features output directory')
+    .option('-f, --features <path>', 'Angular features output directory (optional if configured in generateui-config.json)')
+    .option('-w, --watch', 'Watch .screen.json files and regenerate Angular on changes (default)')
+    .option('--no-watch', 'Run Angular generation once and exit')
     .action(async (options) => {
-    const { telemetry } = program.opts();
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
     try {
         await (0, angular_1.angular)({
             schemasPath: options.schemas,
             featuresPath: options.features,
+            watch: options.watch !== false,
             telemetryEnabled: telemetry
         });
     }
@@ -59,13 +100,14 @@ program
     }
 });
 /**
- * 3️⃣ Login (Dev plan)
+ * 4️⃣ Login (Dev plan)
  */
 program
     .command('login')
     .description('Login to unlock Dev features')
     .action(async () => {
-    const { telemetry } = program.opts();
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
     try {
         await (0, login_1.login)({ telemetryEnabled: telemetry });
     }
@@ -73,9 +115,43 @@ program
         handleCliError(error);
     }
 });
+/**
+ * 5️⃣ Compare generated vs overrides (interactive)
+ */
+program
+    .command('merge')
+    .description('Compare generated vs overrides with an interactive diff tool')
+    .requiredOption('--feature <name>', 'Feature folder or operationId')
+    .option('-f, --features <path>', 'Angular features output directory')
+    .option('--file <name>', 'File to compare: component.ts, component.html, component.scss, or all')
+    .option('--tool <name>', 'Diff tool (code, meld, kdiff3, bc, or any executable)')
+    .action(async (options) => {
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
+    try {
+        await (0, merge_1.merge)({
+            featuresPath: options.features,
+            feature: options.feature,
+            file: options.file,
+            tool: options.tool
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
 function handleCliError(error) {
     if (error instanceof Error) {
         console.error(error.message.replace(/\\n/g, '\n'));
+        if ((0, logger_1.isVerbose)() && error.stack) {
+            console.error('');
+            console.error('🔎 Stack trace:');
+            console.error(error.stack);
+        }
+        else {
+            console.error('');
+            console.error('ℹ️  Tip: re-run with --dev to see detailed logs.');
+        }
     }
     else {
         console.error('Unexpected error');

package/dist/license/guard.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireFeature = requireFeature;
+const config_1 = require("../runtime/config");
 function requireFeature(features, featureKey, reason) {
     if (!features[featureKey]) {
         const details = reason ? ` ${reason}` : '';
-        throw new Error(`Requires Dev plan.${details} Execute \`generate-ui login\` to continue.`);
+        throw new Error(`This feature requires an active paid subscription.${details} Upgrade: ${(0, config_1.getDevPlanUrl)()}`);
     }
 }