arckode-framework 1.0.0

package/cli/commands/make-frontend-module.ts

@@ -0,0 +1,271 @@
+// cli/commands/make-frontend-module.ts — Genera módulo frontend completo
+// Crea: API client, composable, componentes (list + form), página, router
+
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export async function makeFrontendModule(name: string, basePath: string) {
+  const pascal = name.charAt(0).toUpperCase() + name.slice(1).toLowerCase()
+  const kebab = name.toLowerCase()
+  const modulePath = join(basePath, 'modules', kebab)
+
+  await mkdir(join(modulePath, 'api'), { recursive: true })
+  await mkdir(join(modulePath, 'composables'), { recursive: true })
+  await mkdir(join(modulePath, 'components'), { recursive: true })
+  await mkdir(join(modulePath, 'pages'), { recursive: true })
+  await mkdir(join(modulePath, 'router'), { recursive: true })
+
+  // index.ts
+  await writeFile(join(modulePath, 'index.ts'), `// modules/${kebab}/index.ts — PUERTA PÚBLICA
+export { use${pascal} } from './composables/use${pascal}'
+export { default as ${pascal}Page } from './pages/${pascal}Page.vue'
+export { default as ${pascal}List } from './components/${pascal}List.vue'
+export { default as ${pascal}Form } from './components/${pascal}Form.vue'
+export { ${kebab}Routes } from './router'
+export { ${kebab}Api } from './api/${kebab}.api'
+export type { ${pascal}DTO, Create${pascal}DTO } from './types'
+
+export function create${pascal}Module() {
+  return { routes: ${kebab}Routes }
+}
+`)
+
+  // types.ts
+  await writeFile(join(modulePath, 'types.ts'), `// modules/${kebab}/types.ts
+
+export interface ${pascal}DTO {
+  id: string
+  nombre: string
+  activo: boolean
+  createdAt: string
+}
+
+export interface Create${pascal}DTO {
+  nombre: string
+}
+`)
+
+  // api.ts
+  await writeFile(join(modulePath, `api/${kebab}.api.ts`), `// modules/${kebab}/api/${kebab}.api.ts
+
+import type { ${pascal}DTO, Create${pascal}DTO } from '../types'
+
+const BASE_URL = import.meta.env.VITE_API_URL ?? '/api'
+
+async function request<T>(path: string, opts: RequestInit = {}): Promise<T> {
+  const token = localStorage.getItem('arckode_token')
+  const res = await fetch(\`\${BASE_URL}\${path}\`, {
+    ...opts,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(token ? { Authorization: \`Bearer \${token}\` } : {}),
+      ...opts.headers,
+    },
+  })
+  if (!res.ok) throw new Error((await res.json().catch(() => ({}))).error ?? 'Error')
+  return res.json()
+}
+
+export interface PaginatedResponse<T> {
+  data: T[]
+  pagination: { page: number; limit: number; total: number; totalPages: number }
+}
+
+export const ${kebab}Api = {
+  list: (params?: Record<string, string>) => {
+    const q = params ? \`?\${new URLSearchParams(params)}\` : ''
+    return request<PaginatedResponse<${pascal}DTO>>(\`/${kebab}\${q}\`)
+  },
+  create: (data: Create${pascal}DTO) =>
+    request<${pascal}DTO>('/${kebab}', { method: 'POST', body: JSON.stringify(data) }),
+  delete: (id: string) =>
+    request<void>(\`/${kebab}/\${id}\`, { method: 'DELETE' }),
+}
+`)
+
+  // composable
+  await writeFile(join(modulePath, `composables/use${pascal}.ts`), `// modules/${kebab}/composables/use${pascal}.ts
+
+import { ref, computed } from 'vue'
+import { ${kebab}Api } from '../api/${kebab}.api'
+import type { ${pascal}DTO, Create${pascal}DTO } from '../types'
+
+export function use${pascal}() {
+  const items = ref<${pascal}DTO[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  const hasItems = computed(() => items.value.length > 0)
+
+  async function list() {
+    loading.value = true; error.value = null
+    try {
+      const r = await ${kebab}Api.list()
+      items.value = r.data
+    } catch (e) { error.value = (e as Error).message; throw e }
+    finally { loading.value = false }
+  }
+
+  async function create(data: Create${pascal}DTO) {
+    loading.value = true
+    try {
+      const item = await ${kebab}Api.create(data)
+      items.value.push(item)
+      return item
+    } catch (e) { error.value = (e as Error).message; throw e }
+    finally { loading.value = false }
+  }
+
+  async function remove(id: string) {
+    loading.value = true
+    try {
+      await ${kebab}Api.delete(id)
+      items.value = items.value.filter(i => i.id !== id)
+    } catch (e) { error.value = (e as Error).message; throw e }
+    finally { loading.value = false }
+  }
+
+  return { items, loading, error, hasItems, list, create, remove }
+}
+`)
+
+  // components/List.vue
+  await writeFile(join(modulePath, 'components', `${pascal}List.vue`), `<script setup lang="ts">
+import { onMounted } from 'vue'
+import { use${pascal} } from '../composables/use${pascal}'
+
+const { items, loading, error, hasItems, list, remove } = use${pascal}()
+onMounted(() => list())
+
+function confirmarEliminar(id: string, nombre: string) {
+  if (confirm(\`¿Eliminar "\${nombre}"?\`)) remove(id)
+}
+</script>
+
+<template>
+  <div class="list">
+    <div v-if="loading" class="loading">Cargando...</div>
+    <div v-else-if="error" class="error">{{ error }}</div>
+    <div v-else-if="!hasItems" class="empty">No hay ${kebab} registrados</div>
+    <table v-else class="table">
+      <thead><tr><th>Nombre</th><th>Estado</th><th>Acciones</th></tr></thead>
+      <tbody>
+        <tr v-for="item in items" :key="item.id">
+          <td>{{ item.nombre }}</td>
+          <td><span :class="['badge', item.activo ? 'activo' : 'inactivo']">{{ item.activo ? 'Activo' : 'Inactivo' }}</span></td>
+          <td><button @click="confirmarEliminar(item.id, item.nombre)" class="btn-sm btn-danger">Eliminar</button></td>
+        </tr>
+      </tbody>
+    </table>
+  </div>
+</template>
+
+<style scoped>
+.table { width: 100%; border-collapse: collapse; background: white; border-radius: 8px; }
+.table th { background: #f8f9fa; padding: 12px; text-align: left; font-size: 0.85em; color: #666; }
+.table td { padding: 12px; border-top: 1px solid #eee; }
+.badge { padding: 2px 8px; border-radius: 4px; font-size: 0.85em; }
+.badge.activo { background: #f0fdf4; color: #27ae60; }
+.badge.inactivo { background: #fdf0ef; color: #e74c3c; }
+.btn-sm { padding: 4px 12px; border: none; border-radius: 4px; cursor: pointer; font-size: 0.85em; }
+.btn-danger { background: #fee; color: #c0392b; }
+.loading, .error, .empty { padding: 40px; text-align: center; }
+</style>
+`)
+
+  // components/Form.vue
+  await writeFile(join(modulePath, 'components', `${pascal}Form.vue`), `<script setup lang="ts">
+import { ref } from 'vue'
+import { use${pascal} } from '../composables/use${pascal}'
+
+const emit = defineEmits<{ saved: []; canceled: [] }>()
+const { create } = use${pascal}()
+const nombre = ref('')
+const submitting = ref(false)
+const formError = ref<string | null>(null)
+
+async function handleSubmit() {
+  if (!nombre.value.trim()) { formError.value = 'El nombre es requerido'; return }
+  submitting.value = true; formError.value = null
+  try {
+    await create({ nombre: nombre.value })
+    nombre.value = ''
+    emit('saved')
+  } catch (e) { formError.value = (e as Error).message }
+  finally { submitting.value = false }
+}
+</script>
+
+<template>
+  <form @submit.prevent="handleSubmit" class="form">
+    <h3>Nuevo ${pascal}</h3>
+    <div v-if="formError" class="alert alert-error">{{ formError }}</div>
+    <div class="field">
+      <label>Nombre</label>
+      <input v-model="nombre" type="text" placeholder="Nombre" required />
+    </div>
+    <div class="actions">
+      <button type="submit" :disabled="submitting" class="btn-primary">{{ submitting ? 'Guardando...' : 'Guardar' }}</button>
+      <button type="button" @click="emit('canceled')" class="btn-secondary">Cancelar</button>
+    </div>
+  </form>
+</template>
+
+<style scoped>
+.form { background: white; padding: 24px; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 1px 4px rgba(0,0,0,0.05); }
+.field { margin-bottom: 16px; }
+label { display: block; margin-bottom: 4px; font-weight: 600; font-size: 0.85em; }
+input { width: 100%; padding: 8px 12px; border: 1px solid #ddd; border-radius: 4px; }
+.actions { display: flex; gap: 8px; }
+.btn-primary { background: #27ae60; color: white; border: none; padding: 8px 16px; border-radius: 4px; cursor: pointer; }
+.btn-secondary { background: #95a5a6; color: white; border: none; padding: 8px 16px; border-radius: 4px; cursor: pointer; }
+.alert { padding: 8px 12px; border-radius: 4px; margin-bottom: 12px; }
+.alert-error { background: #fdf0ef; color: #e74c3c; }
+</style>
+`)
+
+  // Page.vue
+  await writeFile(join(modulePath, 'pages', `${pascal}Page.vue`), `<script setup lang="ts">
+import { ref } from 'vue'
+import ${pascal}List from '../components/${pascal}List.vue'
+import ${pascal}Form from '../components/${pascal}Form.vue'
+
+const showForm = ref(false)
+</script>
+
+<template>
+  <div class="page">
+    <div class="header">
+      <h1>${pascal}s</h1>
+      <button @click="showForm = !showForm" class="btn-primary">{{ showForm ? 'Cancelar' : 'Nuevo' }}</button>
+    </div>
+    <${pascal}Form v-if="showForm" @saved="showForm = false" @canceled="showForm = false" />
+    <${pascal}List />
+  </div>
+</template>
+
+<style scoped>
+.header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 24px; }
+.btn-primary { background: #27ae60; color: white; border: none; padding: 10px 20px; border-radius: 4px; cursor: pointer; }
+</style>
+`)
+
+  // router
+  await writeFile(join(modulePath, 'router', 'index.ts'), `// modules/${kebab}/router/index.ts
+import type { RouteRecordRaw } from 'vue-router'
+
+export const ${kebab}Routes: RouteRecordRaw[] = [
+  {
+    path: '/${kebab}',
+    name: '${kebab}',
+    component: () => import('../pages/${pascal}Page.vue'),
+    meta: { requiresAuth: true },
+  },
+]
+`)
+
+  console.log(`✅ Módulo frontend "${pascal}" creado en modules/${kebab}`)
+  console.log(`   Registralo en main.ts:`)
+  console.log(`   import { create${pascal}Module, ${kebab}Routes } from './modules/${kebab}'`)
+  console.log(`   const ${kebab} = create${pascal}Module()`)
+  console.log(`   routes: [...${kebab}Routes]`)
+}

package/cli/commands/make-helper.ts

@@ -0,0 +1,65 @@
+// cli/commands/make-helper.ts — Generador de helpers puros
+
+import { mkdir, writeFile, access } from 'node:fs/promises'
+import { join } from 'node:path'
+
+function toKebab(str: string): string {
+  return str
+    .replace(/([A-Z])/g, '-$1')
+    .toLowerCase()
+    .replace(/^-/, '')
+    .replace(/[-_\s]+/g, '-')
+}
+
+function toCamel(str: string): string {
+  return str
+    .replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase())
+    .replace(/^(.)/, c => c.toLowerCase())
+}
+
+function helperStub(name: string): string {
+  const kebab = toKebab(name)
+  const camel = toCamel(name)
+
+  return [
+    `// shared/helpers/${kebab}.ts`,
+    `// Helpers puros — sin estado, sin efectos secundarios, sin dependencias externas`,
+    `// Importar directo desde cualquier módulo: import { ... } from '../../shared/helpers/${kebab}'`,
+    ``,
+    `/**`,
+    ` * Ejemplo: renombrá esta función con algo descriptivo del dominio.`,
+    ` * Patrón A — Helper puro (ver ARCHITECTURE-REFERENCE.md)`,
+    ` */`,
+    `export function ${camel}Example(input: string): string {`,
+    `  return input.trim()`,
+    `}`,
+    ``,
+  ].join('\n')
+}
+
+export async function makeHelper(name: string, basePath: string): Promise<void> {
+  const kebab = toKebab(name)
+  const helpersPath = join(basePath, 'shared', 'helpers')
+
+  await mkdir(helpersPath, { recursive: true })
+
+  const filePath = join(helpersPath, `${kebab}.ts`)
+
+  // No sobreescribir si ya existe
+  try {
+    await access(filePath)
+    console.log(`⚠  El helper "${kebab}.ts" ya existe. Editalo directamente.`)
+    return
+  } catch {
+    // no existe → crear
+  }
+
+  await writeFile(filePath, helperStub(name), 'utf-8')
+
+  console.log(`✅ Helper "${name}" creado en shared/helpers/${kebab}.ts`)
+  console.log(``)
+  console.log(`   Importar desde cualquier módulo:`)
+  console.log(`   import { ${toCamel(name)}Example } from '../../shared/helpers/${kebab}'`)
+  console.log(``)
+  console.log(`   Renombrá la función de ejemplo y agregá la lógica real.`)
+}

package/cli/commands/make-migration.ts

@@ -0,0 +1,30 @@
+// cli/commands/make-migration.ts — Generador de migraciones
+
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { ModuleStubParams } from '../stubs/module-stub'
+import { migrationStub } from '../stubs/module-stub'
+
+export async function makeMigration(name: string, basePath: string) {
+  const pascal = name.charAt(0).toUpperCase() + name.slice(1).toLowerCase()
+  const kebab = name.toLowerCase()
+
+  const params: ModuleStubParams = {
+    name: pascal,
+    module: kebab,
+    fields: [
+      { name: 'id', type: 'string', required: true },
+      { name: 'nombre', type: 'string', required: true },
+      { name: 'activo', type: 'boolean', required: false },
+    ],
+  }
+
+  const migrationsPath = join(basePath, 'migrations')
+  await mkdir(migrationsPath, { recursive: true })
+
+  const content = migrationStub(params)
+  const filename = `${Date.now()}_create_${kebab}.ts`
+
+  await writeFile(join(migrationsPath, filename), content, 'utf-8')
+  console.log(`✅ Migración creada: migrations/${filename}`)
+}

package/cli/commands/make-seed.ts

@@ -0,0 +1,29 @@
+// cli/commands/make-seed.ts — Generador de seeds
+
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { ModuleStubParams } from '../stubs/module-stub'
+import { seedStub } from '../stubs/module-stub'
+
+export async function makeSeed(name: string, basePath: string) {
+  const pascal = name.charAt(0).toUpperCase() + name.slice(1).toLowerCase()
+  const kebab = name.toLowerCase()
+
+  const params: ModuleStubParams = {
+    name: pascal,
+    module: kebab,
+    fields: [
+      { name: 'nombre', type: 'string', required: true },
+    ],
+  }
+
+  const seedPath = join(basePath, 'seeds')
+  await mkdir(seedPath, { recursive: true })
+
+  const content = seedStub(params)
+    .replace(`'${pascal} de ejemplo'`, `'${pascal} #1'`)
+    .replace(`'${pascal} de ejemplo 2'`, `'${pascal} #2'`)
+
+  await writeFile(join(seedPath, `${kebab}.ts`), content, 'utf-8')
+  console.log(`✅ Seed "${pascal}" creado en seeds/${kebab}.ts`)
+}

package/cli/generate.ts

@@ -0,0 +1,132 @@
+// cli/generate.ts — Generador de código para IA
+// SOLID: cada generator produce código 100% correcto con la arquitectura.
+
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { ModuleStubParams } from './stubs/module-stub'
+import {
+  indexStub, typesStub, socketsStub,
+  serviceStub, controllerStub, validatorStub,
+  testStub, migrationStub, seedStub,
+} from './stubs/module-stub'
+
+type StringCase = 'pascal' | 'camel' | 'kebab'
+
+function toCase(str: string, target: StringCase): string {
+  const p = str.replace(/[-_]/g, ' ').replace(/\w+/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).replace(/\s/g, '')
+  if (target === 'pascal') return p
+  if (target === 'camel') return p.charAt(0).toLowerCase() + p.slice(1)
+  return p.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '')
+}
+
+function detectFields(name: string): { name: string; type: 'string' | 'number' | 'boolean'; required: boolean }[] {
+  return [
+    { name: 'nombre', type: 'string', required: true },
+    { name: 'activo', type: 'boolean', required: false },
+  ]
+}
+
+// ─── Generador de módulo completo ───
+export async function generateModule(params: {
+  name: string
+  basePath: string
+  description?: string
+  fields?: Record<string, { type: 'string' | 'number' | 'boolean'; required?: boolean }>
+}): Promise<void> {
+  const { name, basePath } = params
+  const pascal = toCase(name, 'pascal')
+  const kebab = toCase(name, 'kebab')
+
+  const userFields = params.fields ?? detectFields(name)
+  const fieldList = Object.entries(userFields).map(([n, f]) => ({
+    name: n,
+    type: f.type as 'string' | 'number' | 'boolean',
+    required: f.required ?? false,
+  }))
+
+  const stubParams: ModuleStubParams = {
+    name: pascal,
+    module: kebab,
+    fields: fieldList,
+    softDelete: false,
+  }
+
+  const modulePath = join(basePath, 'modules', kebab)
+  await mkdir(join(modulePath, 'actions'), { recursive: true })
+  await mkdir(join(modulePath, 'validators'), { recursive: true })
+  await mkdir(join(modulePath, 'tests'), { recursive: true })
+
+  await writeFile(join(modulePath, 'index.ts'), indexStub(stubParams), 'utf-8')
+  await writeFile(join(modulePath, 'types.ts'), typesStub(stubParams), 'utf-8')
+  await writeFile(join(modulePath, 'sockets.ts'), socketsStub(stubParams), 'utf-8')
+  await writeFile(join(modulePath, 'actions/service.ts'), serviceStub(stubParams), 'utf-8')
+  await writeFile(join(modulePath, 'actions/controller.ts'), controllerStub(stubParams), 'utf-8')
+  await writeFile(join(modulePath, 'validators/schema.ts'), validatorStub(stubParams), 'utf-8')
+  await writeFile(join(modulePath, 'tests/service.test.ts'), testStub(stubParams), 'utf-8')
+
+  // Migration
+  const migrationsPath = join(basePath, 'migrations')
+  await mkdir(migrationsPath, { recursive: true })
+  await writeFile(join(migrationsPath, `${Date.now()}_create_${kebab}.ts`), migrationStub(stubParams), 'utf-8')
+
+  // Seed
+  const seedsPath = join(basePath, 'seeds')
+  await mkdir(seedsPath, { recursive: true })
+  await writeFile(join(seedsPath, `${kebab}.ts`), seedStub(stubParams), 'utf-8')
+
+  console.log(`✅ Módulo "${pascal}" creado en modules/${kebab}`)
+  console.log(`   Archivos: index, types, sockets, service, controller, validators, tests`)
+  console.log(`   Migración: migrations/..._create_${kebab}.ts`)
+  console.log(`   Seed: seeds/${kebab}.ts`)
+  console.log('')
+  console.log(`   Registralo en composition-root.ts:`)
+  console.log(`   import { ${pascal}Module } from './modules/${kebab}'`)
+  console.log(`   import { OrmRepository } from 'arckode-framework'`)
+  console.log(`   import type { ${pascal}DTO } from './modules/${kebab}/types'`)
+  console.log(`   orm.define('${pascal}', { table: '${kebab}', fields: { nombre: { type: 'string' } }, timestamps: true })`)
+  console.log(`   const ${kebab}Repo = new OrmRepository<${pascal}DTO>(orm, '${pascal}')`)
+  console.log(`   system.addModule(${pascal}Module)   // pasar ${kebab}Repo al módulo`)
+}
+
+// ─── Generador de conector ───
+export async function generateConnector(params: {
+  name: string
+  basePath: string
+  modules: string[]
+  description?: string
+}): Promise<void> {
+  const { name, basePath, modules, description = '' } = params
+  const camel = toCase(name, 'camel')
+
+  const connectorPath = join(basePath, 'connectors')
+  await mkdir(connectorPath, { recursive: true })
+
+  await writeFile(join(connectorPath, `${camel}.ts`), [
+    `// connectors/${camel}.ts — Conector entre módulos`,
+    `// Responsabilidad ÚNICA: conectar módulos SIN modificarlos`,
+    `// SOLID: cada conector conecta módulos, no contiene lógica de negocio`,
+    ``,
+    `// Conecta: ${modules.join(' → ')}`,
+    description ? `// Descripción: ${description}` : '',
+    ``,
+    `import type { ConnectorContext } from 'arckode-framework'`,
+    ``,
+    `export function ${camel}(ctx: ConnectorContext): void {`,
+    modules.map(m => `  const ${toCase(m, 'camel')} = ctx.resolveModule<any>('${m}')`).join('\n'),
+    ``,
+    modules.slice(1).map(m => {
+      const prev = toCase(modules[0] ?? '', 'camel')
+      const curr = toCase(m, 'camel')
+      return `  // ${prev} → ${curr}: conectar eventos`
+    }).join('\n'),
+    `}`,
+    ``,
+  ].join('\n'))
+
+  console.log(`✅ Conector "${camel}" creado en ${connectorPath} (conecta: ${modules.join(', ')})`)
+}
+
+function mapFieldType(type: string): string {
+  const map: Record<string, string> = { string: 'string', number: 'number', boolean: 'boolean' }
+  return map[type] ?? 'unknown'
+}