> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart Hono

> Aggiungi Base44 al tuo progetto Hono

Segui questa quickstart per aggiungere Base44 al tuo progetto Hono. Creerai un backend Base44, definirai entità e integrerai l'SDK nei tuoi route API.

<Note>La CLI richiede Node.js 20.19.0 o superiore.</Note>

## Configurazione

<Steps>
  <Step title="Installa la CLI di Base44">
    Installa la CLI di Base44 a livello globale:

    ```bash theme={null}
    npm install -g base44@latest
    ```
  </Step>

  <Step title="Crea un backend Base44">
    Vai nella directory del tuo progetto Hono, quindi esegui:

    ```bash theme={null}
    base44 create
    ```

    Se non hai già effettuato l'accesso, il comando ti chiederà di autenticarti.

    Seleziona **Create a basic project** quando richiesto. Questo crea i file backend all'interno della directory del tuo progetto Hono. Quindi segui le richieste per configurare il tuo progetto.

    Quando crei un progetto, le [skill di Base44](/developers/backend/overview/base44-skills) sono incluse automaticamente, fornendo al tuo agente IA istruzioni e contesto per le attività Base44.
  </Step>

  <Step title="Configura la directory di output (opzionale)">
    Se stai servendo file statici con Hono, aggiorna [config.jsonc](/developers/backend/overview/project-structure) in modo che punti al tuo output di compilazione. Aggiungi o modifica il campo `site.outputDirectory`:

    ```json theme={null}
    {
      "site": {
        "outputDirectory": "dist"
      }
    }
    ```

    <Note>
      Se stai costruendo una pura API con Hono e non stai servendo un frontend, puoi saltare la configurazione di `outputDirectory` o omettere questo passaggio.
    </Note>
  </Step>

  <Step title="Definisci le entità">
    Crea [schemi di entità](/developers/references/entities/introduction) per definire le tue strutture di dati. I file delle entità devono essere posizionati nella directory `base44/entities/`.

    Ad esempio, crea `base44/entities/task.jsonc`:

    ```json theme={null}
    {
      "name": "Task",
      "type": "object",
      "properties": {
        "title": {
          "type": "string"
        },
        "completed": {
          "type": "boolean",
          "default": false
        }
      },
      "required": ["title"]
    }
    ```
  </Step>

  <Step title="Invia le entità a Base44">
    Invia i tuoi schemi di entità a Base44:

    ```bash theme={null}
    base44 entities push
    ```

    Questo comando sincronizza le tue definizioni di entità locali con il tuo backend Base44, rendendole disponibili per l'uso nella tua applicazione. Consulta [`entities push`](/developers/references/cli/commands/entities-push) per maggiori informazioni.
  </Step>

  <Step title="Installa l'SDK di Base44">
    Installa il JavaScript SDK di Base44:

    ```bash theme={null}
    npm install @base44/sdk
    ```
  </Step>

  <Step title="Crea un client Base44">
    Crea un [client](/developers/references/sdk/getting-started/client) SDK di Base44 nel tuo progetto. L'`appId` si trova nel tuo file `base44/.app.jsonc`.

    Ad esempio, crea `lib/base44.js`:

    ```javascript theme={null}
    import { createClient } from '@base44/sdk';

    export const base44 = createClient({
      appId: 'your-app-id-from-app.jsonc'
    });
    ```
  </Step>

  <Step title="Usa l'SDK nei tuoi route API">
    Usa l'SDK di Base44 per interagire con le tue [entità](/developers/references/sdk/docs/type-aliases/entities) negli handler dei route Hono. Ad esempio:

    ```javascript theme={null}
    import { Hono } from 'hono';
    import { base44 } from './lib/base44Client';

    const app = new Hono();

    // Get all tasks
    app.get('/api/tasks', async (c) => {
      const tasks = await base44.entities.Task.list();
      return c.json(tasks);
    });

    // Create a new task
    app.post('/api/tasks', async (c) => {
      const body = await c.req.json();
      const newTask = await base44.entities.Task.create({
        title: body.title,
        completed: false
      });
      return c.json(newTask, 201);
    });

    export default app;
    ```

    <Note>
      Usa il nome esatto dell'entità dal tuo schema quando chiami l'SDK, comprese le maiuscole. Per convenzione, i nomi delle entità iniziano con una lettera maiuscola. Ad esempio, se il tuo schema ha `"name": "Task"`, vi accedi come `base44.entities.Task.list()`.
    </Note>
  </Step>

  <Step title="Esegui la tua API in locale">
    Avvia il tuo server di sviluppo Hono per testare l'integrazione. Dalla root del tuo progetto, esegui:

    ```bash theme={null}
    npm run dev
    ```

    La tua API Hono si connetterà al tuo backend Base44 tramite il client SDK, permettendoti di lavorare con le tue entità distribuite in tempo reale.
  </Step>
</Steps>

## Passaggi successivi

Ora che il tuo backend Base44 è integrato con il tuo progetto, puoi:

* Usare l'[SDK](/developers/references/sdk/getting-started/overview) per aggiungere più funzionalità alla tua API.
* Aggiungere [entità](/developers/backend/resources/entities/overview), [funzioni backend](/developers/backend/resources/functions) e [agenti](/developers/backend/resources/agents-config). Se stai lavorando in TypeScript, [genera i tipi](/developers/references/sdk/getting-started/dynamic-types) per ottenere autocompletamento e sicurezza dei tipi.
* Testare in locale eseguendo [`base44 dev`](/developers/references/cli/commands/dev) per il backend Base44 insieme al tuo dev server Hono. Consulta [Sviluppo locale](/developers/backend/overview/local-dev/local-development-overview) per le istruzioni di configurazione.
* Continuare a sviluppare la tua API e distribuirla secondo il runtime scelto.

## Vedi anche

* [Riferimento comandi CLI](/developers/references/cli/commands/introduction): tutti i comandi CLI disponibili
* [Struttura del progetto](/developers/backend/overview/project-structure): come sono organizzati i file di progetto
* [Documentazione JavaScript SDK](/developers/references/sdk/getting-started/overview): collega la tua app al backend
* [Skill Base44](/developers/backend/overview/base44-skills): insegna agli assistenti IA a lavorare con Base44

<Note>Questa pagina è stata tradotta utilizzando l'IA. Per informazioni più accurate e aggiornate, consulta la [versione inglese](/). </Note>