MetacoreAddons declarativos. UI sin pegamento.

Construí un addon CRUD, obtené una app multi-tenant funcional — sin escribir el cableado.

📜

Manifest, no boilerplate

Declará tablas, columnas, capabilities y acciones en un solo archivo JSON. Obtené migraciones, endpoints REST, metadata y una UI tipada gratis.

🔒

Seguridad capability-first

Los permisos son parte del contrato del addon. El kernel los aplica en cada llamada CRUD, la UI restringe componentes automáticamente.

🦀

Sandbox WASM

Los addons corren aislados en wazero. Se acabó vendorear código Go no confiable dentro de tu binario.

⚡

Hot install

Soltá un bundle firmado, el instalador migra el schema, monta los handlers, registra la metadata de UI. Sin reinicio.

📡

Tiempo real por defecto

Un hub WebSocket es parte del runtime. Empujá cambios CRUD y eventos custom a los clientes con una sola llamada.

🧱

Dos repos, una plataforma

El kernel corre el runtime en Go. El SDK declara el contrato en TypeScript. El portal en el que estás los conecta.

Qué es Metacore?

Metacore es un runtime + SDK para construir aplicaciones de negocio modulares y multi-tenant a partir de pequeños addons declarativos. El kernel es una librería Go que embebés en tu app: posee el schema de la base de datos, la superficie REST, los permisos, el lifecycle y un hub WebSocket. El SDK es un set de packages npm y una CLI: te deja describir un addon — sus tablas, capabilities y UI — en un solo manifest.json, y renderiza el resultado como una experiencia React tipada dentro de cualquier host.

Juntos, convierten un manifest en una app CRUD funcional. Cualquier host que construyas sobre los mismos primitivos — un panel de operador, un portal de cliente, un admin embebido — la levanta automáticamente.

El pitch en cuatro líneas

manifest.jsonendpointsui.tsx

json

{
  "id": "tickets",
  "name": "Tickets",
  "version": "0.1.0",
  "tables": [{
    "name": "tickets",
    "columns": [
      { "name": "id",       "type": "uuid", "primaryKey": true },
      { "name": "title",    "type": "string", "required": true },
      { "name": "status",   "type": "enum",   "values": ["open","closed"] },
      { "name": "assignee", "type": "string" }
    ]
  }],
  "capabilities": [
    { "kind": "db:read",  "target": "tickets" },
    { "kind": "db:write", "target": "tickets" }
  ]
}

bash

# Montados por el kernel, no se necesita código de handler.
GET    /api/addons/tickets/tickets
GET    /api/addons/tickets/tickets/:id
POST   /api/addons/tickets/tickets
PATCH  /api/addons/tickets/tickets/:id
DELETE /api/addons/tickets/tickets/:id
GET    /api/addons/tickets/_meta/columns

tsx

import { DynamicTable } from '@asteby/metacore-runtime-react'

// Lee la misma metadata, obtiene list + paginate + sort + filter.
export default function Tickets() {
  return <DynamicTable addon="tickets" table="tickets" />
}

Ese es todo el loop. Agregá una columna, la tabla se actualiza. Agregá una capability, el middleware de permisos la aplica. Publicá un bundle, el instalador lo carga en caliente.

Elegí el punto de entrada correcto

Estoy construyendo un addon → Vos escribís un manifest, el SDK hace el resto. Publicá un `.mcbundle` en cualquier host corriendo el kernel. Estoy embebiendo el runtime en mi app Go → Soltá el kernel en un server Gin/Chi, obtené CRUD dinámico, permisos y WebSockets out of the box. Estoy construyendo un host → Un frontend Vite + React sobre un backend Go que monta el kernel. El SDK provee cada primitivo.

O saltá directo a la documentación profunda

Referencia del SDK → Los 16 packages npm, el spec del manifest, UI dinámica, el cookbook, capabilities, publicación. Referencia del Kernel → Embeber el runtime, el framework de CRUD dinámico, la API HTTP, permisos y setup para contribuidores.

Qué está abierto

Los dos repositorios de Metacore son públicos y Apache-2.0:

Repo	Qué es
`asteby/metacore-kernel`	El runtime Go. Sandbox WASM, CRUD dinámico, permisos, lifecycle, WebSockets.
`asteby/metacore-sdk`	El SDK TypeScript y la CLI. Schema del manifest, runtime React, scaffolder de addons.
`asteby/metacore`	Este portal. Solo documentación.

El kernel y el SDK cada uno trae su propia documentación profunda — este sitio te dirige a la correcta y explica la plataforma de punta a punta.