• Zuhause
  • Artikel
  • Warum Headless CMS und GraphQL eine natürliche Ergänzung sind
Veröffentlicht am 04-03-2019

Warum Headless CMS und GraphQL eine natürliche Ergänzung sind

Bonus: Takeshape-Demo

Foto von Gabrielle Henderson auf Unsplash

Als wir das erste Mal 2017 über GraphQL geschrieben haben, haben wir es als glänzendes neues Werkzeug beschrieben, das von Facebook entwickelt wurde.

GraphCMS, das wir in diesem Artikel vorgestellt haben, war eine der ersten Software, die es als Kernfunktion verwendete.

Es war nur ein weiterer Tropfen in einem Meer von Entwicklungswerkzeugen. Kein Biggie, richtig?

Nicht ganz.

Ich denke, wir können uns alle einig sein, dass GraphQL jetzt ein integraler Bestandteil des modernen Web-Ökosystems ist.

Beweis Nr. 1: Die Anzahl der statischen Site-Generatoren und Headless-CMS, die es zu einer erstklassigen integrierten Funktion machen, hat in den letzten Monaten in die Höhe geschossen.

Eines davon ist TakeShape.io, das ich am Ende dieses Beitrags in einer technischen Demo näher untersuchen werde

Zuerst möchte ich einen Blick darauf werfen:

  • Der Stand von GraphQL im Jahr 2019
  • Die Vorteile für Headless CMS
  • Die Tools mit GraphQL
  • Eine Einführung in TakeShape.io

Beginnen wir, indem wir uns mit den Konzepten von GraphQL beschäftigen.

1. Mit GraphQL auf den neuesten Stand bringen

Möglicherweise lesen Sie, ohne zu wissen, was GraphQL wirklich ist. Aus Gründen der Klarheit ist dies eine Abfragesprache für APIs, die definiert, wie Daten aus einer oder mehreren Datenbanken abgerufen werden.

Für eine korrekte technische GraphQL-Einführung empfehle ich unseren ersten Beitrag zu diesem Thema.

Seit dem ersten Anwendungsfall mit mobilen Apps von FB im Jahr 2012 hat sich vieles geändert, vor allem hinsichtlich der Einführung. GraphQL wurde im Jahr 2015 auf Open-Source-Basis bereitgestellt, wodurch es für eine größere Anzahl von Entwicklern einen ersten Lebensschub bot. 4 Jahre später ist die wachsende Präsenz in unserer Branche unbestreitbar.

Beweis Nr. 2, dass GraphQL ein wesentlicher Bestandteil der Webentwicklung ist: Die Übernahme durch technische Giganten. Abgesehen von Facebook nutzen auch andere wichtige Player wie GitHub, Shopify, Pinterest, Paypal und Twitter GraphQL in irgendeiner Weise.

Beeindruckend genug, fügt es sich direkt in die Zeit der Annahme, an die Lee Byron, der Schöpfer von GraphQL, vor einigen Jahren gedacht hat. Der nächste Schritt nach ihm? Omnipräsenz in Webplattformen. Wir haben allen Grund, ihm zu glauben.

Bereiten Sie sich darauf vor, 2019 viel über GraphQL zu erfahren. Viele Publikationen halten es für einen der wichtigsten Trends von JS, den Sie in den nächsten Monaten im Auge behalten sollten. Npm selbst sagt, dass Sie es 2019 lernen müssen, und GraphQL-Experten surren bereits über die glänzende Zukunft der Technologie.

Aber… warte mal hier.

Hype ist eine Sache, aber einer meiner Kollegen hat etwas dazu gesagt, was ich sehr interessant fand:

Es ist wahr, dass, wenn intensive öffentliche Gespräche manchmal etwas übertreffen können (der Birdbox-Film, irgendjemand?), Dies auch seine ursprünglichen Vorzüge überschatten kann.

Für uns sind diese Säulen für GraphQL:

  1. Die GraphQL-Spezifikation wurde entwickelt, um einzelne hochflexible API-Endpunkte zu definieren, über die Entwickler auf vollständige relationale Modelle zugreifen können.
    1. Es ist unglaublich leistungsfähig, da es den Verbrauchern vollständige Kontrolle darüber gibt, wie sie die angeforderten Daten strukturieren möchten und wie tief sie in die Entitätenbeziehungen eintauchen möchten.
    2. In gleicher Weise erklärt ein GitHub-Ingenieur, warum er nicht warten kann, bis GraphQL in dieser Episode von JAMstack Radio "uncool" ist.

      Was ist mit dem alten GraphQL vs. REST-Vortrag?

      Ich verliere mich hier nicht zu lange, weil es auch ein Thema ist, über das wir in unserem ersten GraphQL-Artikel diskutiert haben, und die Debatte hat sich nicht wirklich geändert.

      Natürlich zwingt uns die zunehmende Übernahme von GraphQL dazu, diese Diskussion fortzusetzen, aber die REST-APIs sind noch immer lebendig und stehen vorerst nicht zur Verfügung. Sie können sie nicht beiseite legen und sagen, dass einer der Vorgänger des anderen ist, weil sie einfach nicht von derselben Art sind. Sie können in derselben Umgebung gut leben.

      GraphQL ist jedoch ein Upgrade für bestimmte Funktionen, die mit REST-APIs nicht optimal waren.

      2. Wie kopflose CMS GraphQL nutzen

      Wenn Sie in den letzten Monaten besonders aufmerksam waren, haben Sie vielleicht eine Reihe von Tools beobachtet, die GraphQL als integrierte Funktion hinzugefügt haben, oder neue, die mit GraphQL als Verkaufsargument auf den Markt kommen.

      Diese Liste enthält:

      • Gatsby (SSG) - Der beliebte statische Site-Generator von React nutzt GraphQL zum Abrufen von Daten aus mehreren Quellen.
        • Gridsome (SSG) - Das Vue.js-Äquivalent zu Gatsby, auch mit GraphQL.
        • GraphCMS - Der Name sagt alles aus. Es war wahrscheinlich das erste kopflose CMS, das GraphQL voranbrachte.
        • Strapi - Mit diesem übersichtlichen CMS für Node.js können Sie REST- oder GraphQL-APIs verwenden.
        • Unite CMS - Dieses neue Headless CMS ist noch in der Beta-Phase und basiert auf Symfony 4 und GraphQL.
        • CannerCMS - Ein Open-Source-API mit CMS ohne Heads.
        • TakeShape - Mehr zu diesem neuen headless CMS weiter unten.
        • In diesem Beitrag möchte ich mich ausschließlich auf die Headless-CMS in dieser Liste konzentrieren. Genauer gesagt, wie GraphQL sie besser und Ihrer Aufmerksamkeit würdig macht.

          Ich denke, es gibt vier Hauptvorteile, die hervorzuheben sind:

          → Bessere API zum Abrufen von Daten: Die wichtigste Voraussetzung von GraphQL ist, Devs die Möglichkeit zu geben, genau das zu wählen, was sie aus der Datenbank benötigen, und diese Daten auf vorhersagbare Weise zu erhalten. Darüber hinaus können Sie viele Ressourcen in einer einzigen Anforderung abrufen. Verabschieden Sie sich von aufgeblähten Server- / Datenbank-Anfragen.

          → Möglichkeit, Daten aus externen Anwendungen einzufügen: Ist es nicht das, wofür APIs immer verwendet wurden? Sicher, aber noch einmal macht GraphQL diesen Prozess strukturierter und organisierter. Headless CMS ermöglichen eine modulare Entwicklung. Wenn Sie eine App skalieren, müssen Sie einige externe Funktionen anschließen, und GraphQL stellt sicher, dass Sie nur das bekommen, was Sie wirklich benötigen.

          → Tolle Leistung: Kleinere, effizientere Anfragen an Datenbanken und externe Apps sind zweifellos für die Leistung Ihres Systems von Vorteil.

          → Einfache Bereitstellung auf mehreren Kanälen: GraphQL steht für moderne Trends. Mit dem Aufkommen mobiler, tragbarer Technologien und IoT wird es immer wichtiger, APIs zu entwickeln, die problemlos mehrere Kanäle bedienen können.

          Es ist an der Zeit, von der Theorie zur Praxis zu wechseln, mit TakeShape.io als Meerschweinchen.

          3. Was ist TakeShape.io?

          TakeShape ist ein neues JAMstack-orientiertes Tool, das die Funktionen eines Headless-CMS, einer GraphQL-API und eines statischen Site-Generators vereint.

          Es ist erst ein paar Monate alt, seit es im September 2018 offiziell lanciert wurde. Es hat uns mit seinen JAMstack-Inhalten aufgefallen und wir haben es seitdem immer wieder versucht.

          Es wurde unter der Voraussetzung gebaut, dass „Content Management nicht schwer sein sollte“. TakeShape wurde für Entwickler entwickelt und bietet ihnen einen reibungslosen Rahmen, auf dem Projekte erstellt werden können. Dank der intuitiven Benutzeroberfläche und der erforderlichen Funktionen für die effiziente Verwaltung von Inhalten bleiben Content-Entwickler jedoch nicht im Dunkeln.

          Es ist voll und ganz auf die neuesten Entwicklungstrends ausgerichtet, macht das Beste aus der integrierten GraphQL-API und bietet sogar einen eigenen Generator für statische Sites. Machen Sie sich jedoch keine Sorgen, denn mit jedem guten Headless-CMS können Sie auch die Frontend-Technologie Ihrer Wahl anschließen.

          Die Gründer scheinen auch rundum gute Leute aus der kleinen Diskussion zu sein, die wir vor der Erstellung dieser Demo geführt haben.

          4. Technisches Tutorial: Erstellen einer App mit headless CMS & GraphQL

          Kontext

          Die Idee hinter dieser Demo stammt aus einer therapeutischen Praxis, die die Wichtigkeit betont, Dinge aufzulisten, für die Sie dankbar sind, jeden Tag. Ich werde eine kleine App erstellen, mit der Benutzer Einträge an das senden können, was ich Gratitude-Journal nenne. Ich werde dann GraphQL verwenden, um die im Formular übermittelten Daten abzurufen und auf einer Website zu veröffentlichen, auf der diese Einträge angezeigt werden.

          Voraussetzungen:

          • Ein TakeShape-Konto (kostenlos)
          • Ein Netlify-Konto (auch kostenlos)

          Grundsätzlich werde ich TakeShape verwenden, um die Website zu erstellen und die Daten zu speichern. Ich verwende dann die Netlify-Funktionen, um der TakeQL-API Einträge zur GraphQL-Datenbank hinzuzufügen. Netlify-Funktionen dienen als eine Art Proxy, um sicherzustellen, dass die API-Schlüssel nicht der Wildnis ausgesetzt sind und der Eintrag, den ich in meine Datenbank einfüge, im richtigen Status ist.

          Lass uns das machen!

          4.1 TakeShape einrichten

          Zuerst müssen Sie Ihr TakeShape-Projekt einrichten.

          Sobald Ihr Konto erstellt wurde und Sie angemeldet sind, können Sie Ihren ersten Inhaltstyp erstellen. Ein Inhaltstyp in TakeShape ist die Darstellung eines Objekts oder Dokuments in Ihrer Anwendung.

          Wenn Sie beispielsweise ein klassisches E-Commerce-Projekt erstellen, könnten Sie einen Inhaltstyp für Ihre Produkte, einen anderen Inhaltstyp für die Produktkategorien usw. haben. Sie können dann sehr einfach Beziehungen zwischen Ihren Einträgen definieren.

          Ich schlage vor, das Einführungsvideo hier anzusehen. Es dauert ungefähr 20 Minuten und Sie sollten alles bekommen, was Sie wissen müssen, um mit TakeShape zu beginnen.

          Am Ende steht eine GraphQL-Datenbank, die direkt im API-Explorer in der TakeShape-App oder über deren API-Endpunkt abgefragt werden kann. Dies ist eine sehr einfache Möglichkeit, mit GraphQL zu beginnen. Erstellen Sie in diesem Fall zwei Inhaltstypen.

          Die erste ist für die Nachrichten, die Personen auf der Website einreichen können. Nennen wir diesen Inhaltstyp: Eintrag.

          Sie können Ihre Felder definieren, indem Sie die verschiedenen Steuerelemente, die im rechten Bereich der TakeShape-App verfügbar sind, per Drag-and-Drop verschieben. Verwenden Sie in diesem Fall eine einzelne Zeile, um die Nachricht darzustellen. Bitte beachten Sie, dass ich Multiple als Annotation-Wert verwendet habe, sodass wir mehr als einen Eintrag erstellen können.

          Erstellen Sie den zweiten Inhaltstyp, der "Zuhause" ist. Dies ist nützlich, da Sie möchten, dass Ihr Marketing-Team die Formulierung auf der Homepage kontrolliert. Hier bearbeiten sie den Inhalt. Dies ist ein einzelner Eintrag, da er nur einmal hinzugefügt werden kann (es wird nur eine Homepage geben).

          Einfach, war es nicht? Ihr CMS ist jetzt fertig. Sie müssen nur die Website und die Funktion erstellen, mit der Sie Ihrer GraphQL-Datenbank neue Einträge hinzufügen können.

          Zeit, in den Code einzutauchen!

          4.2 Projekt erstellen

          Der Code für TakeShape-Vorlagen und die kommende Netlify-Funktion befinden sich im selben Git-Repository.

          Sie müssen die TakeShape CLI-Tools verwenden, um das Projekt zu initialisieren. Sie können es also über npm installieren.

          npm install takeshape-cli -g

          Erstellen Sie einen neuen Ordner und starten Sie in diesem Ordner ein neues npm-Projekt:

          npm init

          Befolgen Sie die Schritte, um Ihr Projekt wie üblich zu erstellen.

          Dann müssen Sie das TakeShape-Projekt initialisieren:

          tsg init

          Befolgen Sie die Schritte, indem Sie Ihre TakeShape-Anmeldeinformationen eingeben. Sie werden aufgefordert, einige Fragen zu beantworten. Ihre CLI ist gut gemacht, daher sollte dies nicht kompliziert sein.

          Sie sollten jetzt ein paar Dateien in Ihrem Ordner haben. Schreiben Sie, wie von TakeShape CLI vorgeschlagen, eine .gitignore -Datei in das Stammverzeichnis des Ordners und fügen Sie einige zu ignorierende Dateien hinzu:

          Dann können Sie ein neues Git-Repository initialisieren:

          git init

          4.3 Funktion für die GraphQL-Datenbank hinzufügen

          Jetzt ist es an der Zeit, die Netlify-Funktion zu generieren, die für das Senden neuer Einträge an TakeShape verantwortlich ist.

          Wie bereits erwähnt, ist das Einfügen neuer Daten eine einfache Sache des Abfrages. Dies ist nicht etwas, was Sie oft in solchen Demos sehen. Meistens sammeln Sie die Daten nur mit einigen Abfragen und zeigen sie an. In diesem Fall verwenden Sie GraphQL-Mutationen, um neue Einträge zu erstellen.

          Beginnen wir mit dem Hinzufügen einiger Abhängigkeiten. Sie müssen das netlify-lambda npm-Paket installieren, das während des Erstellungsprozesses verwendet wird. Dies ist das von Netlify erstellte CLI-Tool zum lokalen Kompilieren und Testen von Funktionen:

          npm install netlify-lambda --save-dev

          Installieren Sie auch node-fetch, um mit der TakeShape-API zu interagieren:

          npm install node-fetch --save

          Erstellen Sie eine neue Datei im Stammverzeichnis Ihres Projekts mit dem Namen netlify.toml. Dort geben Sie an, wo sich die Funktionen im Projekt befinden. Der Netlify-Buildprozess verwendet diese Datei, um alles korrekt bereitzustellen.

          Die Funktionen müssen in den Build- / Funktionsordner kompiliert werden. Andernfalls werden sie von Netlify nicht angezeigt und sie sind nicht verfügbar. Sie müssen das netlify-lambda CLI-Tool verwenden, um Ihre Funktion zu kompilieren. Die Build-Funktion wird hier hilfreich sein. Diese Funktion erwartet einen Parameter, der den Pfad zu den nicht kompilierten Funktionen darstellt. Ihr Quellcode.

          Öffnen Sie Ihre package.json-Datei und fügen Sie ein neues Skript mit dem Namen build hinzu.

          Dies ist, was Sie in Netlify als Build-Befehl verwenden werden.

          Für diese Demo benötigen Sie zwei eigenständige Netlify-Sites. Einer ist für das Hosten Ihrer Funktionen verantwortlich (dies wird gewissermaßen eine API sein) und der andere wird die Ausgabe von TakeShape, der öffentlichen Website, sein. Ich werde später darauf zurückkommen.

          Erstellen Sie zunächst Ihre Funktion. Erstellen Sie einen neuen Ordner: src / functions im Stammverzeichnis Ihres Projekts. Dann erstellen Sie eine Datei namens add-entry.js.

          Sie müssen eine Mutation in dieser Funktion mithilfe der TakeShape-API ausführen. Es sieht so aus:

          Grundsätzlich schreiben Sie einen neuen Eintrag in die GraphQL-Datenquelle von TakeShape, der standardmäßig nicht aktiviert ist. Ihre Site-Administratoren können die Nachrichten daher überprüfen, bevor sie auf der öffentlichen Website veröffentlicht werden.

          Hier ist der Code für die Funktion selbst:

          Später müssen Sie einige Umgebungsvariablen auf Netlify-Seite konfigurieren, um den TakeShape-API-Schlüssel und die Projekt-ID zu speichern, damit wir sie nicht in GitHub festlegen. Dieser API-Schlüssel ermöglicht es jedem, Daten in Ihre GraphQL-Datenbank einzufügen oder zu löschen. Sie möchten nicht, dass dies extern geteilt wird.

          Übernehmen Sie jetzt diese Dateien. Erstellen Sie mit Github ein neues Repository und pushen Sie das Projekt.

          Öffnen Sie dann Ihr Netlify-Konto und erstellen Sie eine neue Site aus diesem Repository.

          Wechseln Sie in den Site-Einstellungen zu Build & Deploy und scrollen Sie zum Abschnitt Build-Umgebungsvariablen.

          Sie müssen zwei Umgebungsvariablen hinzufügen: TAKESHAPE_API_KEY und TAKESHAPE_PROJECT_ID.

          Jetzt müssen Sie in Ihrem TakeShape-Dashboard einen neuen API-Schlüssel mit Lese- / Schreibberechtigungen erstellen.

          Notieren Sie sich den API-Schlüsselwert, da Sie ihn nicht mehr anzeigen können. Verwenden Sie diesen Wert, um die Umgebungsvariable TAKESHAPE_API_KEY im Dashboard von Netlify anzugeben.

          Um Ihre Projekt-ID zu erhalten, sehen Sie sich die URL im TakeShape-Dashboard an.

          Damit sollte Ihre Funktion nun wie erwartet funktionieren und Sie sollten in der Lage sein, neue Einträge an TakeShape CMS zu senden. Möglicherweise müssen Sie Ihre Site jedoch erneut in Netlify bereitstellen, um sicherzustellen, dass Ihre Funktion die neuen Umgebungsvariablen kennt.

          Um es zu testen, können Sie einen HTTP-Client wie Postman oder Insomnia verwenden.

          4.4 Aufbau der Site

          Nun, da Ihre API fertig ist, können Sie Ihre Website erstellen. Genial.

          Als ich in Vorbereitung auf diese Demo mit TakeShape angefangen habe, wusste ich nicht einmal, dass sie über eine eigene statische Site-Generierungsfunktion verfügten. Das ist meiner Meinung nach wirklich cool. Es ist solide und ermöglicht einen schnellen Start für kleine Projekte, so dass ich es hier verwende.

          Stellen Sie sicher, dass das Projekt, an dem Sie gearbeitet haben, in Ihrem bevorzugten Code-Editor noch geöffnet ist. Als nächstes erstellen Sie die TakeShape-Konfigurationsdatei. Erstellen Sie im Stammverzeichnis Ihres Projekts eine neue Datei mit dem Namen tsg.yml. Hier erstellen Sie Ihre Routen und ordnen ihnen die Vorlagen / Abfragen zu.

          So sieht die Konfiguration aus:

          Was heißt das? Sie haben eine einzige Route, die Homepage, die die Vorlage homepage.html rendert und die Daten aus der Abfrage homepage.graphql verwendet.

          Jede im routes -Array angegebene Seite besteht aus drei Elementen:

          • Der Pfad, der die URL der Seite ist
          • Die Vorlage, die die Ansicht selbst ist, das HTML-Markup
          • Und der Kontext, der die GraphQL-Abfrage ist, die ausgeführt wird und das Ansichtsmodell auffüllt.

          Wenn Sie erst einmal mit der Arbeit beginnen, stellen Sie fest, dass es sehr sinnvoll ist.

          Dort ist auch der staticPath angegeben. Dieser Pfad ist der Ordner, in dem sich alle statischen Elemente wie Javascript oder CSS-Dateien befinden sollen.

          Beginnen Sie mit der Erstellung unserer Abfragedatei. Generieren Sie eine Datei namens homepage.graphql im Ordner src / templates / data.

          Ihre Anfrage gibt die Liste der Einträge und die Homepage-Details zurück. Sie haben Zugriff auf alle diese Informationen in Ihrer Vorlagendatei.

          Erstellen wir eine Datei namens homepage.html im Ordner src / templates / pages:

          Die app.js-Datei kurz vor dem schließenden body-Tag bemerkt? Hier fügen Sie den Code hinzu, der mit Ihrer Netlify-Funktion interagiert. Erstellen Sie diese Datei in einem neuen Ordner namens static im Stammverzeichnis Ihres Projekts:

          Es gibt auch eine Datei mit dem Namen site.css, die im Header der Site enthalten ist. Erstellen Sie diese Datei im statischen Ordner und genau wie app.js (siehe diese Datei auf Github). Dieses Asset wird bereitgestellt und kann direkt in Ihr Markup eingefügt werden.

          Im Wesentlichen werden Sie das Formularsendeereignis abfangen und Ihre Anfrage an die API senden. Das ist ziemlich einfach.

          Sie können es jetzt mit den TakeShape-Tools lokal testen. Navigieren Sie in einer Eingabeaufforderung zu Ihrem Projekt und verwenden Sie die Überwachungsaufgabe:

          tsg beobachten

          Ihr Projekt wird dann in den Build-Ordner kompiliert, der in der Datei tsg.yml konfiguriert wurde. Wenn Sie einen Webserver auf diesem Pfad starten, sollten Sie Ihre Site sehen können.

          4.5 Bereitstellung der Website

          Zuletzt müssen Sie die Site bereitstellen. TakeShape bietet zahlreiche Bereitstellungsoptionen. In diesem Fall bleibe ich bei Netlify, da es einfach zu verwenden ist und ich mich bereits auf die Plattform für die API verlassen muss.

          Öffnen Sie Ihre Projekteinstellungen:

          Anschließend wird Netlify im Integrationsfenster angezeigt. Verbinden Sie Ihr Netlify-Konto.

          Als Nächstes müssen Sie eine statische Site in TakeShape erstellen:

          Füllen Sie das Formular aus, indem Sie als Anbieter Netlify auswählen. Sie können eine neue Netlify-Site direkt aus diesem Formular erstellen.

          Nun die Bereitstellung.

          Die Verwendung von TakeShape CLI ist sehr einfach. Persönlich möchte ich meine Websites mit der Site-ID bereitstellen. Sie finden es in der URL Ihres Browsers, wenn Sie sich im Bearbeitungsformular der statischen Website befinden:

          Dann in Ihrem Terminal:

          tsg deploy --site 

          Bing! Ihre Website sollte jetzt live sein und die API sollte wie erwartet funktionieren.

          Live-Demo und GitHub-Repo

          Falls Sie sich fragen, wie Sie die von Benutzern im Formular gesendeten Nachrichten manuell überwachen und akzeptieren, zeigt Ihnen diese GIF den Weg:

          Sehen Sie sich die Live-Demo hier an
          Siehe das GitHub-Repo hier

          5. Gedanken abschließen

          Beweis Nr. 3, dass GraphQL jetzt ein integraler Bestandteil der Webentwicklung ist: Es ist großartig und lässt sich so gut in moderne Entwicklungsworkflows integrieren. Es ist schwer, nicht wieder dorthin zurückzukehren, wenn Sie es einmal probiert haben.

          Ich hatte eine tolle Zeit mit den Funktionen TakeShape und Netlify. Diese Tools ermöglichen die Erstellung von vollständigen Anwendungen, ohne sich mit Servern und Infrastruktur befassen zu müssen. Sie wissen, darum geht es uns.

          Das TakeShape-Team hat mit seiner Anwendung wirklich gute Arbeit geleistet. Ihr Dashboard ist klar und einfach, ihre API entspricht genau unseren Erwartungen und der Aufbau von Beziehungen zwischen Inhaltstypen ist absolut unkompliziert.

          Ich verbrachte mehr oder weniger einen Tag damit, alles zusammenzubringen. Ich hatte keine größeren Probleme und es war eine ziemlich reibungslose Entwicklungsfahrt.

          Ich hatte nicht das Bedürfnis etwas für diese Demo weiter zu treiben. Es sollte ziemlich einfach sein und zeigen, wie wir Daten programmgesteuert in das CMS einfügen können. Ich denke, dass dieser Stack hervorragend für ein Blog oder eine inhaltsgesteuerte Anwendung geeignet wäre.

          Ich würde auch gerne TakeShape für eine direkte E-Commerce-Integration mit Snipcart verwenden. ;)

          Irgendwelche Fragen? Fühlen Sie sich frei, Kommentare zu treffen, um uns Ihre Gedanken, Rückmeldungen und Fragen zu geben. Wenn dir dieser Beitrag gefallen hat, nimm dir eine Sekunde oder teile auf Twitter!

          Ursprünglich im Snipcart-Blog und in unserem Newsletter veröffentlicht.