Inizia a utilizzare Firebase SQL Connect su iOS

In questa guida rapida, creerai ed eseguirai il deployment di un piccolo database di esempio e vi accederai da un 'app per iOS.

Prerequisiti

Per completare questa guida rapida, ti serviranno:

  • Un ambiente con i seguenti strumenti installati:
    • Una versione recente di Xcode.
    • L'interfaccia a riga di comando di Firebase. Se hai installato NPM, esegui: 
      npm install -g firebase-tools@latest
       In caso contrario, consulta la documentazione per le istruzioni di installazione.
  • Un Account Google.

Tutorial

Tutorial

1. Crea un nuovo progetto Xcode

In Xcode, crea un nuovo progetto con il modello App.

Assegna al progetto il nome Quickstart con l'identificatore pacchetto com.example.Quickstart.

Finestra di dialogo Nuovo progetto di Xcode

Crea il progetto in una cartella vuota, ad esempio ~/qs-ios. Xcode creerà una cartella, ~/qs-ios/Quickstart, che contiene i file di progetto.

2. Inizializza un progetto Firebase

Passa alla directory del progetto Xcode e inizializza un progetto Firebase al suo interno.

 
cd ~/qs-ios
 
firebase login --reauth
 
firebase init dataconnect

Quando richiesto, scegli le seguenti opzioni:

  • Crea un nuovo progetto Firebase.
  • Non creare uno schema con Gemini (in questo tutorial utilizzerai uno schema di esempio precompilato ).
  • Esegui il provisioning di un'istanza e di un database Cloud SQL di prova senza costi.

Accetta i valori predefiniti per tutti gli altri prompt.

Poi, registra l'app per iOS nel progetto Firebase.

firebase apps:create --bundle-id com.example.Quickstart ios ios-quickstart

Quando ti viene chiesto di specificare un ID App Store, premi Invio per saltare il passaggio.

firebase apps:sdkconfig ios -o Quickstart/GoogleService-Info.plist

In Xcode, seleziona File > Add Files to "Quickstart" e seleziona il GoogleService-Info.plist file.

3. Esamina le definizioni GraphQL di esempio

In SQL Connect, definisci tutti gli schemi e le operazioni del database utilizzando GraphQL. Quando hai inizializzato il progetto, la Firebase CLI ha creato alcune definizioni di esempio per aiutarti a iniziare.

 dataconnect/schema/schema.gql (estratto) 
type Movie @table {
  title: String!
  imageUrl: String!
  genre: String
}

type MovieMetadata @table {
  movie: Movie! @unique
  rating: Float
  releaseYear: Int
  description: String
}
 dataconnect/example/queries.gql (estratto) 
query ListMovies @auth(level: PUBLIC) {
  movies {
    id
    title
    imageUrl
    genre
  }
}

4. Esegui il deployment di schemi e operazioni

Ogni volta che apporti modifiche a schemi, query o mutazioni del database, devi eseguire il deployment affinché le modifiche diventino effettive nel database.

 
firebase deploy --only dataconnect

5. Inserisci dati iniziali nel database

Questi dati iniziali ti daranno qualcosa da esaminare quando testi l'app di esempio. Tieni presente che in questo passaggio esegui GraphQL arbitrario, consentito per le attività amministrative.

 
firebase dataconnect:execute dataconnect/seed_data.gql

6. Genera un SDK client per iOS

Questo comando utilizza le definizioni GraphQL per generare un SDK client per iOS specificamente per il tuo database. Utilizza questa libreria nell'app client per eseguire tutte le operazioni del database.

Puoi generare librerie per più piattaforme, tra cui Kotlin per Android, JavaScript per il web e Flutter, aggiungendo definizioni a connector.yaml.

 
firebase dataconnect:sdk:generate
 SDK iOS generato automaticamente (estratto) 
public class ListMoviesQuery {

  // ...

  @MainActor
  public func execute(
    fetchPolicy: QueryFetchPolicy = .preferCache,
  ) async throws -> OperationResult<ListMoviesQuery.Data> {
    var variables = ListMoviesQuery.Variables()

    let ref = dataConnect.query(
      name: "ListMovies", variables: variables, resultsDataType: ListMoviesQuery.Data.self,
      publisher: .observableMacro)

    let refCast = ref as! QueryRefObservation<ListMoviesQuery.Data, ListMoviesQuery.Variables>
    return try await refCast.execute(fetchPolicy: fetchPolicy)
  }
}

7. Aggiungi le dipendenze di Firebase al progetto Xcode

Aggiungi la libreria generata al progetto utilizzando Swift Package Manager. Quando aggiungi la libreria generata, questa includerà in modo transitivo le librerie principali di Firebase e la Firebase SQL Connect libreria.

Nella barra di navigazione di Xcode, seleziona File > Add Package Dependencies > Add Local e scegli la cartella contenente la libreria generata, FirebaseDataConnectGenerated/DataConnectGenerated/. La cartella corretta conterrà un file denominato Package.swift.

8. Scrivi un client iOS di esempio

Sostituisci i contenuti di Quickstart/QuickstartApp.swift con questa semplice app per iOS.

Tieni presente che l'app completa l'accesso al database necessario utilizzando una funzione da l'SDK generato.

 
import SwiftUI
import FirebaseCore
import FirebaseDataConnect
import DataConnectGenerated

@main
struct QuickstartApp: App {
  init() {
    FirebaseApp.configure()
  }
  var body: some Scene {
    WindowGroup {
      ListMovieView()
    }
  }
}

struct ListMovieView: View {
  @State private var moviesData: ListMoviesQuery.Data?

  var body: some View {
    VStack {
      ForEach(moviesData?.movies ?? []) { movie in
        Text(movie.title)
      }
    }
    .task {
      let result = try? await DataConnect.exampleConnector
          .listMoviesQuery.execute()
      self.moviesData = result?.data
    }
  }
}

9. Prova l'app

Da Xcode, esegui l'app di esempio per vederla in azione.

Passaggi successivi

Prova l'estensione SQL Connect VS Code

Quando sviluppi con SQL Connect, ti consigliamo vivamente di utilizzare l' estensione SQL Connect VS Code. Anche se non utilizzi Visual Studio Code come ambiente di sviluppo principale, l'estensione fornisce diverse funzionalità che semplificano lo sviluppo di schemi e operazioni:

  • Un server di linguaggio GraphQL, che fornisce il controllo della sintassi e suggerimenti di completamento automatico specifici a SQL Connect
  • Pulsanti CodeLens in linea con il codice che consentono di leggere e scrivere dati dai file di definizione dello schema ed eseguire query e mutazioni dalle definizioni delle operazioni.
  • Mantiene automaticamente sincronizzati gli SDK generati con le definizioni GraphQL.
  • Configurazione semplificata dell'emulatore locale.
  • Deployment semplificato in produzione.

Utilizza l'emulatore SQL Connect per lo sviluppo locale

Sebbene questo tutorial ti abbia mostrato come eseguire il deployment di SQL Connect schemi e operazioni direttamente in produzione, probabilmente non vorrai apportare modifiche al database di produzione durante lo sviluppo attivo dell'app. Configura invece l' SQL Connect emulatore ed esegui il lavoro di sviluppo su di esso anziché in produzione. L'emulatore configura un'istanza PGlite locale che si comporta in modo simile a un'istanza PostgreSQL live su Cloud SQL.

Scopri come scrivere schemi e operazioni per la tua app

Quando sviluppi app con SQL Connect, la progettazione di schemi e operazioni è una delle attività di sviluppo più importanti e che devi completare per prima.

  • Gemini nella console Firebase è uno strumento di AI che può generare schemi SQL Connect da una descrizione in linguaggio naturale della tua app. Questo strumento può aiutarti a iniziare molto rapidamente, soprattutto se non hai mai lavorato con database relazionali.
  • In alternativa, puoi scrivere direttamente schemi, query e mutazioni del database utilizzando GraphQL. Inizia con le indicazioni riportate in Progettare schemiSQL Connect, quindi continua con le pagine successive per scoprire come scrivere le operazioni.

Scopri come ricevere aggiornamenti in tempo reale da SQL Connect

Puoi utilizzare SQL Connect per scrivere applicazioni client che reagiscono ai dati in tempo reale. Consulta Ricevere aggiornamenti in tempo reale da SQL Connect.