generate-ui-cli 1.0.0

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

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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) {
+    const appRoot = path_1.default.resolve(featuresRoot, '..');
+    const out = path_1.default.join(appRoot, 'generated', 'routes.gen.ts');
+    fs_1.default.mkdirSync(path_1.default.dirname(out), { recursive: true });
+    const content = `
+import { Routes } from '@angular/router'
+
+export const generatedRoutes: Routes = [
+${routes
+        .flatMap(r => {
+        const base = `  {
+    path: '${r.path}',
+    loadComponent: () =>
+      import('../features/${r.folder}/${r.fileBase}.component')
+        .then(m => m.${r.component})
+  }`;
+        const pascal = toPascalCase(r.path);
+        if (pascal === r.path)
+            return [base];
+        const alias = `  {
+    path: '${pascal}',
+    loadComponent: () =>
+      import('../features/${r.folder}/${r.fileBase}.component')
+        .then(m => m.${r.component})
+  }`;
+        return [base, alias];
+    })
+        .join(',\n')}
+]
+`;
+    fs_1.default.writeFileSync(out, content);
+}
+function toPascalCase(value) {
+    if (!value)
+        return value;
+    return value[0].toUpperCase() + value.slice(1);
+}

package/dist/generators/form.generator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFields = generateFields;
+function mapSchema(schema) {
+    if (!schema || !schema.properties)
+        return [];
+    return Object.entries(schema.properties).map(([name, prop]) => ({
+        name,
+        type: prop.type ?? 'string',
+        required: schema.required?.includes(name) ?? false,
+        label: null,
+        placeholder: null,
+        ui: prop.type === 'array' ? 'tags' : null,
+        options: prop.enum ?? null,
+        defaultValue: prop.default ?? null,
+        validations: []
+    }));
+}
+/**
+ * REGRA CRÍTICA:
+ * - Wrapper (ex: article, user) NÃO vira campo de formulário
+ * - Se houver apenas 1 propriedade object, ela é o wrapper
+ */
+function generateFields(endpoint, api) {
+    const schema = endpoint.requestBody?.content?.['application/json']?.schema;
+    const unwrapped = unwrapSchema(schema);
+    const baseSchema = unwrapped ?? schema;
+    if (!baseSchema || !baseSchema.properties)
+        return [];
+    const method = String(endpoint.method || '').toLowerCase();
+    const entity = String(endpoint.operationId || '').replace(/^(Create|Update|Get|Delete)/, '');
+    let finalSchema = baseSchema;
+    if (method === 'post' && entity && api?.components?.schemas) {
+        const schemas = api.components.schemas;
+        const newSchema = unwrapSchema(schemas[`New${entity}`]) ??
+            schemas[`New${entity}`];
+        const updateSchema = unwrapSchema(schemas[`Update${entity}`]) ?? schemas[`Update${entity}`];
+        if (newSchema && updateSchema) {
+            finalSchema = mergeSchemas(newSchema, updateSchema);
+        }
+        else if (newSchema) {
+            finalSchema = newSchema;
+        }
+    }
+    return mapSchema(finalSchema);
+}
+function unwrapSchema(schema) {
+    if (!schema || !schema.properties)
+        return null;
+    const propertyNames = Object.keys(schema.properties);
+    if (propertyNames.length === 1 &&
+        schema.properties[propertyNames[0]]?.type === 'object') {
+        return schema.properties[propertyNames[0]];
+    }
+    return null;
+}
+function mergeSchemas(primary, secondary) {
+    const merged = {
+        type: 'object',
+        properties: {
+            ...(primary?.properties ?? {}),
+            ...(secondary?.properties ?? {})
+        },
+        required: Array.from(new Set([
+            ...(primary?.required ?? []),
+            ...(secondary?.required ?? [])
+        ]))
+    };
+    return merged;
+}

package/dist/generators/infer-entity.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferEntity = inferEntity;
+function inferEntity(endpoint) {
+    const parts = endpoint.path
+        .split('/')
+        .filter(Boolean)
+        .filter(p => !p.startsWith('{'));
+    if (!parts.length)
+        return 'Unknown';
+    const raw = parts[0];
+    // remove plural simples (users -> user)
+    const singular = raw.endsWith('s')
+        ? raw.slice(0, -1)
+        : raw;
+    return capitalize(singular);
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}

package/dist/generators/infer-submit-wrapper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferSubmitWrapper = inferSubmitWrapper;
+function inferSubmitWrapper(endpoint) {
+    const schema = endpoint.requestBody?.content?.['application/json']?.schema;
+    if (!schema?.properties)
+        return null;
+    const keys = Object.keys(schema.properties);
+    if (keys.length === 1 &&
+        schema.properties[keys[0]]?.type === 'object') {
+        return keys[0];
+    }
+    return null;
+}

package/dist/generators/screen.generator.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScreen = generateScreen;
+const form_generator_1 = require("./form.generator");
+function inferScreen(method, hasInput) {
+    if (method === 'get') {
+        if (hasInput) {
+            return { type: 'form', mode: 'filter' };
+        }
+        return { type: 'view', mode: 'readonly' };
+    }
+    if (method === 'post') {
+        return { type: 'form', mode: 'create' };
+    }
+    if (method === 'put' || method === 'patch') {
+        return { type: 'form', mode: 'edit' };
+    }
+    return { type: 'view', mode: 'readonly' };
+}
+function inferActions(method, hasInput) {
+    if (method === 'get' && hasInput) {
+        return { primary: { type: 'submit', label: 'Buscar' } };
+    }
+    if (method === 'post') {
+        return { primary: { type: 'submit', label: 'Criar' } };
+    }
+    if (method === 'put' || method === 'patch') {
+        return { primary: { type: 'submit', label: 'Salvar' } };
+    }
+    return {};
+}
+function inferSubmitWrap(endpoint) {
+    const schema = endpoint.requestBody?.content?.['application/json']?.schema;
+    if (!schema?.properties)
+        return null;
+    const keys = Object.keys(schema.properties);
+    if (keys.length === 1)
+        return keys[0];
+    return null;
+}
+function generateScreen(endpoint, api) {
+    const fields = (0, form_generator_1.generateFields)(endpoint, api);
+    const method = endpoint.method.toLowerCase();
+    const baseUrl = api?.servers?.[0]?.url;
+    const queryParams = extractQueryParams(endpoint, api);
+    const pathParams = extractPathParams(endpoint.path, api);
+    const hasInput = fields.length > 0 ||
+        queryParams.length > 0 ||
+        pathParams.length > 0;
+    const openapiVersion = api?.info?.version || 'unknown';
+    const screenMeta = buildMeta(endpoint.operationId, 'api', openapiVersion);
+    return {
+        meta: screenMeta,
+        entity: endpoint.summary
+            ? String(endpoint.summary).trim()
+            : endpoint.operationId.replace(/^(Create|Update|Get)/, ''),
+        screen: inferScreen(method, hasInput),
+        description: endpoint.description ?? null,
+        api: {
+            operationId: endpoint.operationId,
+            endpoint: endpoint.path,
+            method,
+            baseUrl,
+            pathParams,
+            queryParams,
+            submit: inferSubmitWrap(endpoint)
+                ? { wrap: inferSubmitWrap(endpoint) }
+                : undefined
+        },
+        layout: { type: 'single' },
+        fields: decorateFields(fields, 'body', openapiVersion),
+        actions: inferActions(method, hasInput),
+        data: {}
+    };
+}
+function extractQueryParams(endpoint, api) {
+    const params = endpoint?.parameters ?? [];
+    return params
+        .filter((param) => param?.in === 'query')
+        .map((param) => ({
+        name: param.name,
+        type: param.schema?.type ?? 'string',
+        required: Boolean(param.required),
+        label: toLabel(param.name),
+        placeholder: param.schema?.example ?? null,
+        options: param.schema?.enum ?? null,
+        defaultValue: param.schema?.default ?? null,
+        hint: param.description ?? null,
+        meta: buildMeta(`query:${param.name}`, 'api', api?.info?.version || 'unknown')
+    }));
+}
+function extractPathParams(path, api) {
+    const params = [];
+    const regex = /{([^}]+)}/g;
+    let match = regex.exec(path);
+    while (match) {
+        params.push(match[1]);
+        match = regex.exec(path);
+    }
+    return params.map(name => ({
+        name,
+        type: 'string',
+        required: true,
+        label: toLabel(name),
+        placeholder: toLabel(name),
+        options: null,
+        defaultValue: null,
+        hint: null,
+        meta: buildMeta(`path:${name}`, 'api', api?.info?.version || 'unknown')
+    }));
+}
+function toLabel(value) {
+    return String(value)
+        .replace(/[_-]/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/\b\w/g, char => char.toUpperCase());
+}
+function buildMeta(id, source, openapiVersion) {
+    return {
+        id,
+        source,
+        lastChangedBy: source,
+        introducedBy: source,
+        openapiVersion,
+        autoAdded: false,
+        userRemoved: false
+    };
+}
+function decorateFields(fields, scope, openapiVersion) {
+    return fields.map(field => ({
+        ...field,
+        meta: field.meta || buildMeta(`${scope}:${field.name}`, 'api', openapiVersion)
+    }));
+}

package/dist/generators/screen.merge.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeScreen = mergeScreen;
+const PRESENTATION_KEYS = [
+    'label',
+    'placeholder',
+    'hint',
+    'info',
+    'ui',
+    'group',
+    'hidden'
+];
+function mergeScreen(nextScreen, overlay, prevGenerated, options) {
+    const debug = [];
+    if (!overlay) {
+        return { screen: normalizeScreen(nextScreen, options), debug };
+    }
+    const normalizedNext = normalizeScreen(nextScreen, options);
+    const normalizedOverlay = normalizeScreen(overlay, options, 'user');
+    const normalizedPrev = prevGenerated
+        ? normalizeScreen(prevGenerated, options)
+        : null;
+    const merged = {
+        ...normalizedNext,
+        entity: normalizedOverlay.entity ?? normalizedNext.entity,
+        screen: normalizedOverlay.screen ?? normalizedNext.screen,
+        layout: normalizedOverlay.layout ?? normalizedNext.layout,
+        actions: mergeActions(normalizedNext.actions, normalizedOverlay.actions)
+    };
+    merged.api = {
+        ...normalizedNext.api,
+        pathParams: mergeFieldList(normalizedNext.api?.pathParams ?? [], normalizedOverlay.api?.pathParams ?? [], normalizedPrev?.api?.pathParams ?? [], options, debug, 'path'),
+        queryParams: mergeFieldList(normalizedNext.api?.queryParams ?? [], normalizedOverlay.api?.queryParams ?? [], normalizedPrev?.api?.queryParams ?? [], options, debug, 'query')
+    };
+    merged.fields = mergeFieldList(normalizedNext.fields ?? [], normalizedOverlay.fields ?? [], normalizedPrev?.fields ?? [], options, debug, 'body');
+    merged.meta = mergeMeta(normalizedNext.meta, normalizedOverlay.meta, options.openapiVersion);
+    return { screen: merged, debug };
+}
+function mergeActions(nextActions, overlayActions) {
+    if (!overlayActions)
+        return nextActions;
+    const merged = { ...nextActions };
+    if (overlayActions.primary?.label) {
+        merged.primary = merged.primary || {};
+        merged.primary.label = overlayActions.primary.label;
+    }
+    return merged;
+}
+function mergeFieldList(nextFields, overlayFields, prevFields, options, debug, scope) {
+    const nextMap = indexById(nextFields, scope);
+    const overlayMap = indexById(overlayFields, scope);
+    const prevMap = indexById(prevFields, scope);
+    const result = [];
+    const overlayOrder = overlayFields.map(field => getId(field, scope));
+    const used = new Set();
+    for (const id of overlayOrder) {
+        const overlayField = overlayMap.get(id);
+        const nextField = nextMap.get(id);
+        const prevField = prevMap.get(id);
+        used.add(id);
+        if (!nextField) {
+            debug.push(`REMOVED_BY_API ${id}`);
+            continue;
+        }
+        if (overlayField?.meta?.userRemoved) {
+            result.push({
+                ...nextField,
+                hidden: true,
+                meta: {
+                    ...mergeMeta(nextField.meta, overlayField.meta, options.openapiVersion),
+                    userRemoved: true,
+                    lastChangedBy: 'user'
+                }
+            });
+            debug.push(`PRESERVE_USER_REMOVED ${id}`);
+            continue;
+        }
+        result.push(mergeField(nextField, overlayField, prevField, options, debug));
+    }
+    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,
+            hidden: autoAdded ? true : nextField.hidden,
+            meta: {
+                ...mergeMeta(nextField.meta, nextField.meta, options.openapiVersion),
+                autoAdded
+            }
+        });
+        debug.push(`ADDED_BY_API ${id}`);
+    }
+    return result;
+}
+function mergeField(nextField, overlayField, prevField, options, debug) {
+    const merged = { ...nextField };
+    const meta = mergeMeta(nextField.meta, overlayField?.meta, options.openapiVersion);
+    for (const key of PRESENTATION_KEYS) {
+        if (overlayField && overlayField[key] !== undefined) {
+            merged[key] = overlayField[key];
+        }
+    }
+    if (prevField && prevField.required !== nextField.required) {
+        if (nextField.required) {
+            merged.hidden = false;
+            debug.push(`OPTIONAL_TO_REQUIRED ${meta.id}`);
+        }
+        else {
+            debug.push(`REQUIRED_TO_OPTIONAL ${meta.id}`);
+        }
+    }
+    if (prevField && prevField.type !== nextField.type) {
+        merged.ui = undefined;
+        merged.options = nextField.options ?? null;
+        debug.push(`TYPE_CHANGED ${meta.id}`);
+    }
+    const prevEnum = Array.isArray(prevField?.options);
+    const nextEnum = Array.isArray(nextField?.options);
+    if (prevEnum && !nextEnum) {
+        merged.options = null;
+        debug.push(`ENUM_TO_STRING ${meta.id}`);
+    }
+    if (!prevEnum && nextEnum) {
+        merged.options = nextField.options;
+        debug.push(`STRING_TO_ENUM ${meta.id}`);
+    }
+    merged.meta = meta;
+    return merged;
+}
+function normalizeScreen(screen, options, fallbackSource = 'api') {
+    if (!screen)
+        return screen;
+    const openapiVersion = options.openapiVersion;
+    const meta = screen.meta || buildMeta(screen.api?.operationId || 'screen', fallbackSource, openapiVersion);
+    return {
+        ...screen,
+        meta,
+        fields: normalizeFieldList(screen.fields, 'body', fallbackSource, openapiVersion),
+        api: {
+            ...screen.api,
+            pathParams: normalizeFieldList(screen.api?.pathParams, 'path', fallbackSource, openapiVersion),
+            queryParams: normalizeFieldList(screen.api?.queryParams, 'query', fallbackSource, openapiVersion)
+        }
+    };
+}
+function normalizeFieldList(list, scope, fallbackSource, openapiVersion) {
+    if (!Array.isArray(list))
+        return [];
+    return list.map(field => ({
+        ...field,
+        meta: field.meta || buildMeta(`${scope}:${field.name}`, fallbackSource, openapiVersion)
+    }));
+}
+function indexById(fields, scope) {
+    const map = new Map();
+    for (const field of fields) {
+        map.set(getId(field, scope), field);
+    }
+    return map;
+}
+function getId(field, scope) {
+    return field?.meta?.id || `${scope}:${field?.name}`;
+}
+function mergeMeta(nextMeta, overlayMeta, openapiVersion) {
+    const base = {
+        ...(nextMeta || overlayMeta),
+        openapiVersion
+    };
+    if (overlayMeta) {
+        base.source = overlayMeta.source || base.source;
+        base.introducedBy = overlayMeta.introducedBy || base.introducedBy;
+        base.lastChangedBy = overlayMeta.lastChangedBy || base.lastChangedBy;
+        base.userRemoved = overlayMeta.userRemoved || base.userRemoved;
+    }
+    return base;
+}
+function buildMeta(id, source, openapiVersion) {
+    return {
+        id,
+        source,
+        lastChangedBy: source,
+        introducedBy: source,
+        openapiVersion,
+        autoAdded: false,
+        userRemoved: false
+    };
+}

package/dist/index.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const generate_1 = require("./commands/generate");
+const angular_1 = require("./commands/angular");
+const login_1 = require("./commands/login");
+const config_1 = require("./runtime/config");
+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');
+/**
+ * 1️⃣ OpenAPI → Screen schemas
+ */
+program
+    .command('generate')
+    .description('Generate screen schemas from OpenAPI')
+    .requiredOption('-o, --openapi <path>', 'OpenAPI file')
+    .option('-d, --debug', 'Explain merge decisions')
+    .action(async (options) => {
+    const { telemetry } = program.opts();
+    try {
+        await (0, generate_1.generate)({
+            openapi: options.openapi,
+            debug: options.debug,
+            telemetryEnabled: telemetry,
+            telemetryCommand: 'generate'
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+/**
+ * 2️⃣ Screen schemas → Angular code
+ */
+program
+    .command('angular')
+    .description('Generate Angular code from screen schemas')
+    .requiredOption('-s, --schemas <path>', 'Directory containing generate-ui (with overlays/)')
+    .requiredOption('-f, --features <path>', 'Angular features output directory')
+    .action(async (options) => {
+    const { telemetry } = program.opts();
+    try {
+        await (0, angular_1.angular)({
+            schemasPath: options.schemas,
+            featuresPath: options.features,
+            telemetryEnabled: telemetry
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+/**
+ * 3️⃣ Login (Dev plan)
+ */
+program
+    .command('login')
+    .description('Login to unlock Dev features')
+    .action(async () => {
+    const { telemetry } = program.opts();
+    try {
+        await (0, login_1.login)({ telemetryEnabled: telemetry });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+/**
+ * 4️⃣ Regenerate with safe merge
+ */
+program
+    .command('regenerate')
+    .description('Regenerate screen schemas with safe merge')
+    .requiredOption('-o, --openapi <path>', 'OpenAPI file')
+    .option('-d, --debug', 'Explain merge decisions')
+    .action(async (options) => {
+    const { telemetry } = program.opts();
+    try {
+        await (0, generate_1.generate)({
+            openapi: options.openapi,
+            debug: options.debug,
+            telemetryEnabled: telemetry,
+            telemetryCommand: 'regenerate',
+            requireSafeRegeneration: true
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+function handleCliError(error) {
+    if (error instanceof Error) {
+        console.error(error.message.replace(/\\n/g, '\n'));
+    }
+    else {
+        console.error('Unexpected error');
+    }
+    process.exit(1);
+}
+program.parse();

package/dist/license/device.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDeviceIdentity = loadDeviceIdentity;
+exports.saveDeviceIdentity = saveDeviceIdentity;
+exports.incrementFreeGeneration = incrementFreeGeneration;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.generateui');
+const DEVICE_PATH = path_1.default.join(CONFIG_DIR, 'device.json');
+function ensureConfigDir() {
+    fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function newDeviceIdentity() {
+    const deviceId = typeof crypto_1.default.randomUUID === 'function'
+        ? crypto_1.default.randomUUID()
+        : crypto_1.default.randomBytes(16).toString('hex');
+    return {
+        deviceId,
+        createdAt: new Date().toISOString(),
+        freeGenerationsUsed: 0
+    };
+}
+function loadDeviceIdentity() {
+    ensureConfigDir();
+    if (!fs_1.default.existsSync(DEVICE_PATH)) {
+        const identity = newDeviceIdentity();
+        fs_1.default.writeFileSync(DEVICE_PATH, JSON.stringify(identity, null, 2));
+        return identity;
+    }
+    const raw = fs_1.default.readFileSync(DEVICE_PATH, 'utf-8');
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed.deviceId) {
+            throw new Error('Invalid device identity');
+        }
+        return parsed;
+    }
+    catch {
+        const identity = newDeviceIdentity();
+        fs_1.default.writeFileSync(DEVICE_PATH, JSON.stringify(identity, null, 2));
+        return identity;
+    }
+}
+function saveDeviceIdentity(identity) {
+    ensureConfigDir();
+    fs_1.default.writeFileSync(DEVICE_PATH, JSON.stringify(identity, null, 2));
+}
+function incrementFreeGeneration() {
+    const identity = loadDeviceIdentity();
+    identity.freeGenerationsUsed += 1;
+    saveDeviceIdentity(identity);
+    return identity;
+}

package/dist/license/guard.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireFeature = requireFeature;
+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.`);
+    }
+}