harvey h

harvey h

1662537379

Laravel Vs Ruby on Rails: Checkout the Difference Between

In order to ensure hassle-free internal operation, clear rationale, and security, it is imperative to equip the #backend of your application with the right technology. 🙂

Backend frameworks, such as #rubyonrails development services or #Laravel development services, are huge, so choosing the right one can be a challenge. click 👇🏻to read the detailed comparison so you can make the right choice

https://aglowiditsolutions.com/blog/laravel-vs-ruby-on-rails/

Laravel Vs Ruby on Rails: Checkout the Difference Between

Xormstore: XORM Backend for Gorilla Sessions

XORM backend for gorilla sessions

go get github.com/lafriks/xormstore

Example

// initialize and setup cleanup
store := xormstore.New(engine, []byte("secret"))
// db cleanup every hour
// close quit channel to stop cleanup
quit := make(chan struct{})
go store.PeriodicCleanup(1*time.Hour, quit)
// in HTTP handler
func handlerFunc(w http.ResponseWriter, r *http.Request) {
  session, err := store.Get(r, "session")
  session.Values["user_id"] = 123
  store.Save(r, w, session)
  http.Error(w, "", http.StatusOK)
}

For more details see xormstore godoc documentation.

Testing

Just sqlite3 tests:

go test

All databases using docker:

./test

If docker is not local (docker-machine etc):

DOCKER_IP=$(docker-machine ip dev) ./test

Download Details:

Author: lafriks
Source Code: https://github.com/lafriks/xormstore 
License: MIT license

#go #golang #backend 

Xormstore: XORM Backend for Gorilla Sessions

Dynamostore: A Session Store Backend for Gorilla/sessions

DynamoStore

A session store backend for gorilla/sessions - src.

Installation

go get github.com/denizeren/dynamostore

Documentation

Available on godoc.org.

See http://www.gorillatoolkit.org/pkg/sessions for full documentation on underlying interface.

Example

// Fetch new store.
store, err := NewDynamoStore("AWS_ACCESS_KEY", "AWS_SECRET_KEY", "DYNAMODB_TABLE_NAME", "AWS_REGION_NAME", "SECRET-KEY")
if err != nil {
    panic(err)
}

// Get a session.
session, err = store.Get(req, "session-key")
if err != nil {
    log.Error(err.Error())
}

// Add a value.
session.Values["foo"] = "bar"

// Save.
if err = sessions.Save(req, rsp); err != nil {
    t.Fatalf("Error saving session: %v", err)
}

// Delete session.
session.Options.MaxAge = -1
if err = sessions.Save(req, rsp); err != nil {
    t.Fatalf("Error saving session: %v", err)
}

Requirements

Depends on the Goamz/aws Go Amazon Library

Depends on the Goamz/dynamodb Go Amazon Dynamodb Library

Download Details:

Author: Denizeren
Source Code: https://github.com/denizeren/dynamostore 
License: MIT license

#go #golang #backend 

Dynamostore: A Session Store Backend for Gorilla/sessions
Monty  Boehm

Monty Boehm

1660146000

Ragel-julia: A Julia backend for Ragel

This is a fork of ragel that adds a Julia backend to the yet unreleased ragel 7.0.

Here's a quick example:

using Switch

%%{
    machine Test1;

    action dgt      { @printf("DGT: %c\n", fc); }
    action dec      { @printf("DEC: .\n"); }
    action exp      { @printf("EXP: %c\n", fc); }
    action exp_sign { @printf("SGN: %c\n", fc); }
    action number   { println("NUMBER") }

    number = (
        [0-9]+ $dgt ( '.' @dec [0-9]+ $dgt )?
        ( [eE] ( [+\-] $exp_sign )? [0-9]+ $exp )?
    ) %number;

    main := ( number '\n' )*;
}%%


function parse(data::String)
    p = 0
    pe = length(data)
    %% write data;
    %% write init;
    %% write exec;
end

parse("1234.56")

Saving the above as number.rl and running ragel -U number.rl" will generate a file number.jl`, which is very efficient, pure Julia number parser.

                 Ragel State Machine Compiler -- README
                 ======================================
  1. Build Requirements

  • Make
  • g++

If you would like to modify Ragel and need to build Ragel's scanners and parsers from the specifications then set "build_parsers=yes" the DIST file and reconfigure. This variable is normally set to "no" in the distribution tarballs and "yes" in version control. You will need the following programs:

  • ragel (the most recent version)
  • kelbt (the most recent version)

To build the user guide set "build_manual=yes" in the DIST file and reconfigure. You will need the following extra programs:

  • fig2dev
  • pdflatex
  1. Compilation and Installation

Ragel uses autoconf and automake.

$ ./configure --prefix=PREFIX $ make $ make install


To build, you will need version 0.12.0 of colm.

The resulting Julia code relies on goto expressions, which are not yet in Julia, but I have a pull request that adds them: https://github.com/JuliaLang/julia/pull/5699.

It also relies on the (Switch)[https://github.com/dcjones/Switch.jl] package that adds C-style switch statements to Julia. That also uses gotos so its not yet available from the package manager.


Download Details:

Author: dcjones
Source Code: https://github.com/dcjones/ragel-julia 
License: GPL-2.0 license

#julia #backend 

Ragel-julia: A Julia backend for Ragel

Explorando La Mejor Plataforma Back-end De Web3

Desde el nacimiento de la primera cadena de bloques programable ( Ethereum ), la demanda de desarrolladores de backend y frontend de Web3 se ha disparado. A su vez, numerosos programadores quieren aprovechar la oportunidad y preparar su carrera para el futuro convirtiéndose en desarrolladores de Web3. Sin embargo, muchos aspirantes a desarrolladores de blockchain encuentran que el backend de Web3 es desalentador. Por lo tanto, ¿no sería muy beneficioso si hubiera una plataforma Web3 que pudiera simplificar la programación de back-end? Si lo hubiera, podría dirigir todos sus esfuerzos, tiempo y recursos para crear una interfaz fenomenal. Además, podría evitar construir el backend de su dApp desde cero. Afortunadamente, esto es literalmente lo que ofrece la mejor plataforma back-end de Web3.

No hace mucho tiempo, la única forma de construir sobre Ethereum era ejecutar sus propios nodos RPC . Además, había que construir todo desde cero. Incluso características tan básicas como la autenticación Web3 podrían haber tardado semanas en desarrollarse. No solo requería mucho tiempo, sino que también obligó a los desarrolladores a lidiar con todas las limitaciones de los nodos RPC . Ahora, avance rápidamente hasta 2022, y tiene a su disposición una pila de tecnología Web3 bastante impresionante . Para empezar, hay bastantes cadenas programables de buena reputación para elegir. Además, muchos proveedores de API y nodos de buena reputacióntambién facilitar las cosas. Sin embargo, estas no son las principales soluciones back-end de Web3. El verdadero atajo de back-end de Web3 viene en forma de la mejor plataforma de back-end de Web3: Moralis .

¿Qué es un back-end?

El backend, también conocido como el lado del servidor, se refiere a todas las funcionalidades que se ejecutan sin que los clientes (usuarios) las vean. Si bien el frontend es todo lo que interesa a los usuarios, es el backend el que normalmente hace todo el trabajo pesado.

Es posible que haya oído hablar de pilas de tecnología back-end como LAMP y MEAN. El primero incluye Linux, Apache MySQL, PHP, mientras que el segundo incluye MongoDB, Express, Angular, NodeJS. Además, una parte vital de cualquier backend es una base de datos. 

Las bases de datos se utilizan para almacenar y estructurar información y sirven como almacenamiento persistente. A través de las funcionalidades CRUD, las bases de datos permiten agregar, leer, actualizar y eliminar datos. Además, tenga en cuenta que existen varios tipos de bases de datos. Más importante aún, para la discusión de hoy, tenga en cuenta que las cadenas de bloques también son un tipo específico de base de datos. Son bases de datos públicas, inmutables y solo para agregar.

Entonces, para resumir: el backend es una parte de una aplicación (u otra operación) a la que los usuarios no tienen acceso y que permite que la aplicación funcione.

¿Por qué necesita un backend Web3?

Ahora que todos sabemos qué es un backend y que blockchain es esencialmente un tipo particular de base de datos, probablemente ya sepa por qué necesita un backend Web3, ¿verdad? Bueno, solo para asegurarnos de que todos estamos en la misma sintonía, analicemos eso. Si las cadenas de bloques son bases de datos y si las bases de datos son una parte vital de un backend, entonces, por definición, no podemos interactuar con blockchains sin un backend de Web3. Esto significa que incluso la aplicación dApp o Web3 más simple necesita un backend adecuado. Además, cuanto mejor backend tenga, mejor funcionará su dApp. Además, una dApp con un backend de calidad también ofrecerá más funcionalidad. Por lo tanto, no limitará la interfaz. Sin embargo, asegúrese de tener en cuenta que no todos los backends son igualmente buenos. 

Por ejemplo, comunicarse directamente con la cadena de bloques o incluso con un nodo RPC es bastante limitante. Ambas capas son bastante primitivas. Es el equivalente a comunicarse con la CPU al construir un sitio web. ¿Puedes ceerlo? Aquí es donde las API entran en escena. Además, en realidad hay muchos proveedores de API Web3 confiables y de buena reputación disponibles (consulte la lista a continuación). 

Algunas de nuestras principales selecciones de API de back-end de Web3:

  • Moralis
  • covalente
  • La gráfica
  • QuickNode
  • Alquimia
  • Bitquería
  • Biconomía

Sin embargo, al observar el sistema heredado, podemos ver que las plataformas son la herramienta de referencia para crear aplicaciones con la máxima facilidad. Firebase, Azure y Amazon Web Service (AWS) han sido herramientas invaluables para el desarrollo de Web2. Por lo tanto, podemos esperar el mismo patrón en el desarrollo de Web3. Ahora, mientras que algunos proveedores de nodos y API intentan posicionarse como plataformas de desarrollo Web3, carecen del rango de funcionalidad para llamarse realmente plataformas. Sin embargo, con un equipo de desarrolladores dedicados y cuidadosos, Moralis logró convertirse exactamente en eso: la última plataforma back-end de Web3.   

La Mejor Plataforma Web3 Backend – Conozca a Moralis

En este punto, sabe que las plataformas son los mejores atajos para crear aplicaciones. ¿Cómo? Bueno, cubren la mayor parte del trabajo pesado relacionado con el backend. Sin embargo, algunos son mejores que otros. Por ejemplo, hay una plataforma disponible que le permite simplemente copiar y pegar fragmentos cortos de código para incluir incluso las funciones de back-end más avanzadas. Esto es exactamente lo que ofrece Moralis, y también es cómo Moralis ha ayudado a los desarrolladores a reducir el tiempo promedio de desarrollo de dApp en más del 80 por ciento. Por lo tanto, su apodo " Firebase para criptografía " y su reconocimiento como la mejor opción y conocida como la mejor plataforma para la programación de back-end de Web3. 

En el futuro, repasaremos las principales funcionalidades de la mejor plataforma back-end de Web3 y le mostraremos con qué facilidad puede comenzar. Al igual que con la plataforma heredada, su primer paso es crear una cuenta Moralis gratuita. Al hacerlo, obtiene acceso a todas las herramientas necesarias para crear aplicaciones descentralizadas de forma rápida y sencilla . Además de las constantes mejoras, incluida la adición de soporte para nuevas cadenas programables, Moralis también escucha a sus usuarios. Como tal, ahora utiliza Ethers.js ( Web3.js vs Ethers.js ) según una solicitud de la comunidad. Además, este mes también se ha estrenado Moralis Nitro . Este último agrega muchas funciones avanzadas y aumenta significativamente la velocidad.     

Explorando el SDK de Moralis 

El uso de bibliotecas de JavaScript y la API de Ethereum le ofrece muchas opciones. Sin embargo, estos vienen con ciertas limitaciones. Afortunadamente, Moralis le permite superar esas limitaciones fácilmente. Por un lado, la interoperabilidad entre cadenas es donde Moralis ofrece una ventaja sin igual. Dado que el SDK de Moralis es compatible con varias cadenas de bloques programables, puede preparar su trabajo para el futuro. Al crear un servidor Moralis para múltiples cadenas, puede implementar sus dApps en todas las cadenas de bloques compatibles. Además, Moralis le permite trabajar de manera eficiente con los datos en cadena. 

Cuando desee crear aplicaciones de próxima generación, debe tener un backend Web3 adecuado a su disposición. Para crear esa infraestructura usted mismo, le llevaría semanas o meses. Además, necesitaría un equipo completo de desarrolladores de back-end para mantenerlo. Por lo tanto, evidentemente, esta no es la forma más óptima, especialmente si ni siquiera está seguro de si a los usuarios les gustará su interfaz. Por lo tanto, tiene sentido utilizar la infraestructura existente. Además, dado que todavía existen muchas limitaciones con los proveedores de nodos y API (ambos le brindan datos sin procesar), usar la mejor plataforma de back-end de Web3 es la solución óptima. Le permite evitar reinventar la rueda y concentrarse en lo que realmente importa: la experiencia del usuario.

Arsenal Web3 de Moralís

Moralis hace las cosas extremadamente simples y prácticas. Le permite hacer todo lo siguiente y más después de iniciar sesión en su cuenta:

  • Poner en marcha su servidor con unos pocos clics.
  • Arrancando tu propia base de datos.
  • Obtenga la API definitiva automáticamente.
  • Obtenga opciones de sincronización automáticamente.
  • La capacidad de escribir código del lado del servidor.
  • Acceda a eventos, activadores y webhooks en tiempo real ( sincronización e indexación de contratos inteligentes ).
  • Una forma ordenada de almacenar todos los datos en vivo en la cadena (en el panel de control de Moralis: indexe la cadena de bloques ).

Aquí está la lista de características clave que mejor describen a Moralis:

Como tal, asegúrese de unirse a otros desarrolladores que usan Moralis para simplificar el desarrollo de Web3:

Cómo comenzar a usar la mejor plataforma backend de Web3

Cuando se trata de crear dApps, tiene dos opciones. Puede usar el último modelo de dApp de Ethereum o la API Moralis Web3 para crear dApps desde cero. De cualquier manera, debe completar la configuración inicial. Para que sea lo más sencillo posible para usted, lo hemos dividido en dos partes.

Configuración inicial de Moralis - Parte 1 

  1. Cree su cuenta Moralis : utilice el enlace de la izquierda para acceder a la página de registro. Allí, podrá crear su cuenta gratuita ingresando su dirección de correo electrónico y creando su contraseña. No olvide confirmar su cuenta (haga clic en el enlace de confirmación enviado a su correo electrónico). Por otro lado, si ya tienes una cuenta de Moralis activa, solo inicia sesión .
  2. Cree un nuevo servidor : después de iniciar sesión con éxito en su área de administración de Moralis, navegue hasta la opción "Servidores" en el lado izquierdo de la pestaña de navegación. Allí, haga clic en "+ Crear un nuevo servidor" en la esquina superior derecha. A continuación, seleccione el tipo de red que mejor se adapte a sus necesidades en el menú desplegable (vea la imagen a continuación). Ir con la opción "Testnet Server" ( conectarse a Ethereum testnets ) tiende a ser la mejor opción cuando se trabaja en proyectos de ejemplo.

Después de seleccionar el tipo de servidor, verá una ventana emergente que le pedirá los detalles del servidor. Por lo tanto, ingrese el nombre de su servidor y seleccione su región, red y cadena(s):

Finalmente, inicia su servidor haciendo clic en el botón "Agregar instancia". Tenga en cuenta que el servidor puede tardar un tiempo en activarse. 

Configuración inicial de Moralis - Parte 2 

  1. Acceder a los detalles del servidor : una vez que haya creado su servidor Moralis, puede acceder a sus detalles haciendo clic en el botón "Ver detalles" junto al nombre de su servidor:


Los detalles se mostrarán en una nueva ventana emergente. Hay iconos de copia establecidos para copiar los detalles en cuestión:

  1. Inicializar Moralis : para inicializar Moralis y acceder a toda la potencia de su SDK, incluida la API Web3, debe completar su archivo de codificación. Si está comenzando desde cero, será un archivo ".html", ".jsx" o ".js". Sin embargo, en caso de que esté utilizando el repetitivo Web3 más práctico , deberá completar el archivo ".env". Aquí es donde copia y pega los detalles de su servidor Moralis (ID de la aplicación y URL del servidor):
    1. Usando el último modelo de Web3:

  1. Creación de dApps desde cero (archivo ".js"):

Nota: asegúrese de usar los detalles de su servidor y NO los detalles de la imagen de arriba.

En el futuro, lo alentamos a que ponga en práctica las instrucciones anteriores y cree su primera dApp lo antes posible. Como tal, te familiarizarás con el uso de tu arsenal recién obtenido. Sin embargo, si no sabes por dónde empezar, te recomendamos que te orientes en el canal de YouTube de Moralis y en el blog de Moralis . Ambos puntos de venta ofrecen innumerables proyectos de ejemplo. Por lo tanto, puede seguir a los expertos de Moralis mientras crean diferentes dApps de ejemplo interesantes. Además, nuestro contenido también es una excelente manera de continuar con su educación gratuita sobre blockchain. Por ejemplo, algunos de nuestros temas más recientes cubren la gamificación Web3 , los personajes de juegos NFT , cómo acuñar 10,000 NFT , la ciencia de datos Web3, las principales API de blockchain , contratos inteligentes ERC721 , contratos inteligentes actualizables , cómo obtener la clave API de OpenSea y mucho más. 

Resumen

Hemos cubierto bastante terreno en este artículo. En caso de que sea un desarrollador frontend de Web2 que busque convertirse en un desarrollador de blockchain , debe estar muy emocionado en este punto. Saber que existe una plataforma de back-end Web3 que le permite usar sus habilidades de JavaScript para crear dApps operables entre cadenas es bastante notable. Al crear su cuenta Moralis gratuita y encender su servidor, está todo listo y puede comenzar a usar la mejor plataforma de back-end de Web3 instantáneamente. Luego, puede comenzar desde cero o incluso reducir aún más su tiempo de desarrollo utilizando el modelo estándar de Ethereum . Además, ahora que sabe que no necesita preocuparse por el backend de Web3, asegúrese de llevar su "juego A" al frontend. 

Esta historia se publicó originalmente en https://moralis.io/exploring-the-best-web3-backend-platform/ 

#web3 #backend 

Explorando La Mejor Plataforma Back-end De Web3
坂本  篤司

坂本 篤司

1655217360

最高のWeb3バックエンドプラットフォームを探る

最初のプログラム可能なブロックチェーン(イーサリアム)の誕生以来、Web3バックエンドおよびフロントエンド開発者の需要は急増しています。同様に、多くのプログラマーは、Web3開発者になることで、チャンスをつかみ、将来を見据えたキャリアを望んでいます。ただし、意欲的なブロックチェーン開発者の多くは、Web3のバックエンドが気が遠くなるようなものだと感じています。したがって、バックエンドプログラミングを簡素化できるWeb3プラットフォームがあれば、それは非常に有益ではないでしょうか。もしあれば、驚異的なフロントエンドの作成にすべての努力、時間、リソースを向けることができます。さらに、dAppのバックエンドを最初から構築することを回避できます。幸いなことに、これは文字通り最高のWeb3バックエンドプラットフォームが提供するものです。

少し前までは、イーサリアム上に構築する唯一の方法は、独自のRPCノードを実行することでした。さらに、すべてをゼロから構築する必要がありました。Web3認証のような基本的な機能でさえ、開発に数週間かかる可能性があります。これは非常に時間がかかるだけでなく、開発者はRPCノードのすべての制限に対処する必要がありました。さて、2022年に早送りすると、かなり印象的なWeb3技術スタックを自由に利用できます。手始めに、選択できる評判の良いプログラム可能なチェーンがかなりたくさんあります。さらに、多くの評判の良いAPIおよびノー​​ドプロバイダーまた、物事を簡単にします。ただし、これらは主要なWeb3バックエンドソリューションではありません。実際のWeb3バックエンドショートカットは、最高のWeb3バックエンドプラットフォームであるMoralisの形で提供されます

バックエンドとは何ですか?

バックエンドはサーバー側とも呼ばれ、クライアント(ユーザー)に表示されることなく実行されるすべての機能を指します。フロントエンドはユーザーの関心を引くすべてですが、通常、すべての面倒な作業を行うのはバックエンドです。

LAMPやMEANなどのバックエンドテクノロジースタックについて聞いたことがあるかもしれません。前者にはLinux、Apache MySQL、PHPが含まれ、後者にはMongoDB、Express、Angular、NodeJSが含まれます。さらに、バックエンドの重要な部分はデータベースです。 

データベースは、情報の保存と構造化に使用され、永続的なストレージとして機能します。CRUD機能を介して、データベースはデータの追加、読み取り、更新、および削除を可能にします。また、データベースにはさまざまな種類があることに注意してください。さらに重要なことに、今日の議論では、ブロックチェーンも特定のタイプのデータベースであることに注意してください。これらは、パブリックで不変の追加専用データベースです。

つまり、要約すると、バックエンドは、ユーザーがアプリケーションの操作を可能にするアクセス権を持たないアプリケーション(または他の操作)の一部です。

なぜWeb3バックエンドが必要なのですか?

バックエンドとは何か、そしてブロックチェーンは本質的に特定のタイプのデータベースであることがわかったので、Web3バックエンドが必要な理由をすでに理解しているでしょう。さて、私たち全員が同じページにいることを確認するために、それについて詳しく説明しましょう。ブロックチェーンがデータベースであり、データベースがバックエンドの重要な部分である場合、定義上、Web3バックエンドなしでブロックチェーンと対話することはできません。これは、最も単純なdAppまたはWeb3アプリケーションでも適切なバックエンドが必要であることを意味します。さらに、バックエンドが優れているほど、dAppの実行はスムーズになります。さらに、高品質のバックエンドを備えたdAppは、より多くの機能も提供します。したがって、フロントエンドを制限することはありません。ただし、すべてのバックエンドが同等に優れているわけではないことに注意してください。 

たとえば、ブロックチェーンと直接通信したり、RPCノードと通信したりすることは非常に制限されます。これらのレイヤーはどちらもかなり原始的です。これは、Webサイトを構築するときにCPUと通信するのと同じです。想像できますか?ここでAPIが登場します。さらに、実際には非常に多くの信頼できる信頼できるWeb3 APIプロバイダーが利用可能です(以下のリストを参照)。 

私たちのトップWeb3バックエンドAPIのいくつかは次のとおりです。

  • モラリス
  • 共有結合
  • グラフ
  • QuickNode
  • 錬金術
  • ビットクエリ
  • バイコノミー

ただし、レガシーシステムを見ると、プラットフォームがアプリケーションを最も簡単に作成するための頼りになるツールであることがわかります。Firebase、Azure、Amazon Web Service(AWS)は、Web2開発のための貴重なツールです。したがって、Web3開発でも同じパターンが期待できます。現在、一部のノードおよびAPIプロバイダーは、Web3開発プラットフォームとしての地位を確立しようとしていますが、実際にプラットフォームと呼ばれる機能の範囲が不足しています。しかし、献身的で思いやりのある開発者のチームにより、Moralisはまさにそれ、つまり究極のWeb3バックエンドプラットフォームになることができました。   

最高のWeb3バックエンドプラットフォーム–Moralisに会う

この時点で、プラットフォームがアプリケーションを作成するための究極のショートカットであることがわかります。どのように?まあ、彼らはあなたのために重いバックエンド関連のリフティングのほとんどをカバーしています。ただし、一部は他よりも優れています。たとえば、コードの短いスニペットをコピーして貼り付けるだけで、最先端のバックエンド機能を含めることができるプラットフォームが1つあります。これはまさにMoralisが提供するものであり、Moralisが開発者の平均dApp開発時間を80%以上短縮するのに役立った方法でもあります。そのため、そのニックネームは「Firebase for crypto」であり、最高の選択肢として認識されており、Web3バックエンドプログラミングに最適なプラットフォームとして知られています。 

今後は、最高のWeb3バックエンドプラットフォームの主な機能を確認し、簡単に開始できることを示します。従来のプラットフォームと同様に、最初のステップは無料のMoralisアカウントを作成することです。そうすることで、分散型アプリをすばやく簡単に構築するために必要なすべてのツールにアクセスできます。新しいプログラム可能なチェーンのサポートを追加するなど、絶え間ない改善に加えて、Moralisはユーザーの話にも耳を傾けます。そのため、コミュニティからの要求に基づいて、Ethers.js(Web3.jsとEthers.js )を利用するようになりました。さらに、MoralisNitroも今月リリースされました。後者は多くの高度な機能を追加し、速度を大幅に向上させます。     

MoralisのSDKを探索する 

JavaScriptライブラリとEthereumAPIを使用すると、多くのオプションが提供されます。ただし、これらには特定の制限があります。幸いなことに、Moralisを使用すると、これらの制限を簡単に埋めることができます。1つは、クロスチェーンの相互運用性が、Moralisが比類のない利点を提供するところです。MoralisのSDKはいくつかのプログラム可能なブロックチェーンをサポートしているため、将来にわたって利用できます。複数のチェーン用のMoralisサーバーを作成することで、サポートされているすべてのブロックチェーンにdAppをデプロイできます。さらに、Moralisを使用すると、オンチェーンデータを効率的に操作できます。 

次世代のアプリケーションを作成する場合は、適切なWeb3バックエンドを自由に使用できるようにする必要があります。そのインフラストラクチャを自分で作成するには、数週間から数か月かかります。また、それを維持するには、バックエンド開発者のチーム全体が必要になります。したがって、これは明らかに最適な方法ではありません。特に、ユーザーがフロントエンドを気に入ってくれるかどうかさえわからない場合はなおさらです。したがって、既存のインフラストラクチャを使用することは理にかなっています。さらに、ノードプロバイダーとAPIプロバイダー(どちらも生データを提供します)にはまだ多くの制限があるため、最適なWeb​​3バックエンドプラットフォームを使用することが最適なソリューションです。これにより、車輪の再発明を回避し、本当に重要なこと、つまりユーザーエクスペリエンスに集中することができます。

モラリスのWeb3アーセナル

モラリスは物事を非常にシンプルで実用的なものにします。アカウントにログインした後、次のすべてを実行できます。

  • 数回クリックするだけでサーバーを起動します。
  • 独自のデータベースを起動します。
  • 究極のAPIを自動的に取得します。
  • 同期オプションを自動的に取得します。
  • サーバー側でコードを作成する機能。
  • リアルタイムのイベント、トリガー、およびWebhookにアクセスします(スマートコントラクトの同期とインデックス作成)。
  • ライブのオンチェーンデータをすべて保存するための適切な方法(Moralisのダッシュボード:ブロックチェーンにインデックスを付ける)。

Moralisを最もよく表す主な機能のリストは次のとおりです。

そのため、Web3開発を簡単にするためにMoralisを使用している他の開発者に参加するようにしてください。

最高のWeb3バックエンドプラットフォームの使用を開始する方法

dAppの作成に関しては、2つのオプションがあります。究極のEthereumdAppボイラープレートまたはMoralisWeb3APIを使用して、dAppを最初から構築できます。いずれにせよ、初期設定を完了する必要があります。できるだけわかりやすくするために、2つの部分に分けました。

モラリスの初期設定–パート1 

  1. Moralisアカウントを作成する 左側のリンクを使用して、サインアップページにアクセスします。そこで、メールアドレスを入力してパスワードを作成することで、無料のアカウントを作成できます。アカウントを確認することを忘れないでください(メールに送信された確認リンクをクリックしてください)。一方、すでにアクティブなMoralisアカウントをお持ちの場合は、ログインするだけです。
  2. 新しいサーバーの作成– Moralis管理エリアに正常にログインしたら、ナビゲーションタブの左側にある[サーバー]オプションに移動します。そこで、右上隅にある[+新しいサーバーを作成する]をクリックします。次に、ドロップダウンメニューからニーズに最適なネットワークタイプを選択します(下の画像を参照)。「TestnetServer」オプション(Ethereum testnetsに接続)を使用することは、サンプルプロジェクトで作業する場合に最適なオプションになる傾向があります。

サーバーの種類を選択すると、サーバーの詳細を尋ねるポップアップウィンドウが表示されます。したがって、サーバーの名前を入力し、リージョン、ネットワーク、およびチェーンを選択します。

最後に、「インスタンスの追加」ボタンをクリックしてサーバーを起動します。サーバーが起動するまでに時間がかかる場合があることに注意してください。 

モラリスの初期設定–パート2 

  1. サーバーの詳細へのアクセス– Moralisサーバーを作成したら、サーバー名の横にある[詳細の表示]ボタンをクリックして、その詳細にアクセスできます。


詳細は新しいポップアップウィンドウに表示されます。問題の詳細をコピーするためのコピーアイコンが設定されています。

  1. Moralisの初期化– Moralisを初期化し、Web3 APIを含むSDKの全機能にアクセスするには、コーディングファイルにデータを入力する必要があります。ゼロから始める場合、これは「.html」、「。jsx」、または「.js」ファイルになります。ただし、最も実用的なWeb3ボイラープレートを使用している場合は、「。env」ファイルにデータを入力する必要があります。ここで、Moralisサーバーの詳細(アプリケーションIDとサーバーURL)をコピーして貼り付けます。
    1. 究極のWeb3ボイラープレートの使用:

  1. dAppを最初から構築する(「.js」ファイル):

注:上の画像の詳細ではなく、サーバーの詳細を使用してください

今後は、上記の手順を使用して、最初のdAppをできるだけ早く作成することをお勧めします。そのため、新しく入手した武器の使用法に慣れることができます。ただし、どこから始めればよいかわからない場合は、MoralisYouTubeチャンネルMoralisブログでガイダンスを探すことをお勧めします。これらのアウトレットは両方とも、無数のサンプルプロジェクトを提供しています。したがって、Moralisの専門家がさまざまな興味深い例のdAppを作成するので、彼らをフォローすることができます。さらに、私たちのコンテンツは、無料のブロックチェーン教育を継続するための優れた方法でもあります。たとえば、最新のトピックのいくつかは、Web3ゲーミフィケーションNFTゲームのキャラクター10,000 NFTを作成する方法Web3データサイエンスをカバーしています。トップブロックチェーンAPIERC721スマートコントラクトアップグレード可能なスマートコントラクト、 OpenSeaAPIキーの取得方法など。 

概要

この記事では、かなり多くのことを取り上げました。あなたがブロックチェーン開発者になりたいと考えているWeb2フロントエンド開発者である場合、この時点でかなり興奮している必要があります。JavaScriptスキルを使用してクロスチェーンで操作可能なdAppを作成できるWeb3バックエンドプラットフォームがあることを知っていることは非常に注目に値します。無料のMoralisアカウントを作成してサーバーを起動することで、すべての準備が整い、最高のWeb3バックエンドプラットフォームを即座に使用できるようになります。次に、 Ethereumボイラープレートを使用して、ゼロから開始することも、開発時間をさらに短縮することもできます。さらに、Web3バックエンドについて自分で心配する必要がないことがわかったので、必ず「Aゲーム」をフロントエンドに持ってきてください。 

このストーリーは、もともとhttps://moralis.io/exploring-the-best-web3-backend-platform/で公開されました 

#web3 #backend 

最高のWeb3バックエンドプラットフォームを探る

A Fetch API Polyfill for React Native

fetch

A fetch API polyfill for React Native with text streaming support

This is a fork of GitHub's fetch polyfill, the fetch implementation React Native currently provides. This project features an alternative fetch implementation directy built on top of React Native's Networking API instead of XMLHttpRequest for performance gains. At the same time, it aims to fill in some gaps of the WHATWG specification for fetch, namely the support for text streaming.

In practice, this implementation is a drop-in replacement to GitHub's polyfill as it closely follows its implementation. Do not use this implementation if your application does not require to stream text.

Motivation

GitHub's fetch polyfill, originally designed with the intention to be used in web browsers without support for the fetch standard, most notably does not support the consumption of a response body as a stream.

However, as React Native does not yet provide direct access to the underlying byte stream for responses, we either have to fallback to XMLHttpRequest or React Native's networking API for iOS and Android. Currently, only strings can be transfered through the bridge, thus binary data has to be base64-encoded (source) and while React Native's XHR provides progress events to receive incremental data, it concatenates the response string as data comes in. Although very inefficient, the response can be sliced up, each chunk encoded into its UTF-8 representation with TextEncoder and finally enqueued to the stream.

Instead of relying on XMLHttpRequest, which degrades performance, we remove it out of the equation and have fetch interact with React Native's Networking API directly instead. To make Response.body work, ReadableStream's controller was integrated with native progress events. It's important to stress that progress events are only fired when the native response type is set to text (https://github.com/facebook/react-native/blob/v0.63.4/Libraries/Network/RCTNetworking.mm#L544-L547), therefore limiting streaming to text-only transfers. If you wish to consume binary data, either blob or base64 response types have to be used. In this case, the downside is that the final response body is read as a whole and enqueued to the stream's controller as a single chunk. There is no way to read a partial response of a binary transfer.

For more context, read the following:

Related:

Requirements

React Native v0.62.0+ is the minimum version supported where the Networking API has been made public.

This implementation depends on the following web APIs which are not currently available in React Native:

It should be possible remove the dependency on TextEncoder and TextDecoder, but not on ReadableStream. Either way, beware the bundle size of your application will inevitable increase.

To polyfill the above APIs, use react-native-polyfill-globals.

Install

$ npm install react-native-fetch-api --save

Setup

The APIs provided by GitHub's implementation in React Native have to be replaced by those provided by this implementation. To do so, check and install react-native-polyfill-globals and follow the instructions therein.

Usage

No need to import anything after the setup is done. All APIs will be available globally.

Example:

fetch('https://jsonplaceholder.typicode.com/todos/1')
  .then(response => response.json())
  .then(json => console.log(json))

Check fetch's official documentation to learn more about the concepts and extended usage.

Enable text streaming

A non-standard option was added to fetch to enable incremental events in React Native's networking layer.

fetch('https://jsonplaceholder.typicode.com/todos/1', { reactNative: { textStreaming: true } })
  .then(response => response.body)
  .then(stream => ...)

Aborting requests

It's possible to abort an on-going request and React Native already supports AbortController, so there is no need for a polyfill.

const controller = new AbortController();

fetch('https://jsonplaceholder.typicode.com/todos/1', { signal: controller.signal })
  .then(response => response.json())
  .then(json => console.log(json))

Learn more about aborting fetch at https://developers.google.com/web/updates/2017/09/abortable-fetch.

Cookies

There is no concept of Cross-Origin Resource Sharing (CORS) in native apps. React Native only accepts a boolean value for the credentials option. As such, to send cookies you can either use same-origin and include.

The Set-Cookie response header returned from the server is a forbidden header name and therefore can't be programmatically read with response.headers.get(). Instead, the platform's native networking stack automatically manages cookies for you.

If you run into issues with cookie-based authentication, read the following:

Alternatively, you may consider using the react-native-cookies.

Request caching directive

The only values supported for the cache option are no-cache and no-store and Both achieve exactly the same result. All other values are ignored. Following GitHub's implementation, a cache-busting mechanism is provided by using the query parameter _ which holds the number of milliseconds elapsed since the Epoch when either no-cache or no-store are specified.

Redirect modes directive

The fetch specification defines these values for the redirect option: follow (the default), error, and manual. React Native does not accept such option but it does transparently follow a redirect response given the Location header for 30x status codes.

Tests

To run the test suite, you must use react-native-test-runner CLI. Run the run-tests.js wrapper script to spin up a local HTTP server to execute the networking tests against.

iOS

$ ./run-tests.js --platform ios --simulator '<simulator>' test/index.js 

Where <simulator> can be a combination of a device type and iOS version, e.g. iPhone 11 (14.1), or a device UUID. Check which simulators are available in your system by running the following command:

$ xcrun xctrace list devices

Android

$ ./run-tests.js --platform android --emulator '<emulator>' test/index.js 

Where <emulator> is the name of the Android Virtual Device (AVD), e.g. Pixel_API_28_AOSP. Check which emulators are available in your system by running the following command:

$ emulator -list-avds

Download Details:
Author: react-native-community
Source Code: https://github.com/react-native-community/fetch
License: MIT license

#react  #reactnative  #mobileapp  #javascript  #backend 

A Fetch API Polyfill for React Native

How to Download & Upload Blobs In React Native

react-native-blob-courier

Use this library to efficiently download and upload data in React Native. The library was inspired by rn-fetch-blob, and is focused strictly on http file transfers.

Installation

Install using yarn

yarn add react-native-blob-courier

Or install using npm

npm install react-native-blob-courier

Requirements

  • Android >= 21
  • Android Gradle Plugin >= 7
  • iOS >= 10
  • JDK >= 11
  • React Native >= 0.63.x

Note: you may have success with earlier versions of React Native but these are neither tested nor supported.

Usage

The library provides both a fluent and a more concise interface. In the examples the concise approach is applied; fluent interface is demonstrated later in this document.

Straightforward down- and upload

import BlobCourier from 'react-native-blob-courier';

// ...

// Download a file
const request0 = {
  filename: '5MB.zip',
  method: 'GET',
  mimeType: 'application/zip',
  url: 'http://ipv4.download.thinkbroadband.com/5MB.zip',
};

const fetchedResult = await BlobCourier.fetchBlob(request0);
console.log(fetchedResult);
// {
//   "data": {
//     "absoluteFilePath": "/path/to/app/cache/5MB.zip",
//     "response": {
//       "code":200,
//       "headers": {
//         "some_header": "some_value",
//         ...
//       }
//     },
//   },
//   "type":"Unmanaged"
// }

// ...

// Upload a file
const absoluteFilePath = fetchedResult.data.absoluteFilePath;

const request1 = {
  absoluteFilePath,
  method: 'POST',
  mimeType: 'application/zip',
  url: 'https://file.io',
};

const uploadResult = await BlobCourier.uploadBlob(request1);

console.log(uploadResult):
// {
//   "response": {
//     "code": {
//     "data": "<some response>",
//     "headers": {
//       "some_header": "some_value",
//        ...
//      }
//   }
// }

// Multipart file upload
const absoluteFilePath = fetchedResult.data.absoluteFilePath;

const request2 = {
  method: 'POST',
  parts: {
    body: {
      payload: 'some_value',
      type: 'string',
    },
    file: {
      payload: {
        absoluteFilePath,
        mimeType: 'application/zip',
      },
      type: 'file',
    },
  },
  url: 'https://file.io',
};

const multipartUploadResult = await BlobCourier.uploadBlob(request1);

console.log(multipartUploadResult):
// {
//   "response": {
//     "code": {
//     "data": "<some response>",
//     "headers": {
//       "some_header": "some_value",
//        ...
//      }
//   }
// }

Transfer progress reporting

import BlobCourier from 'react-native-blob-courier';

// ...

// Download a file
const request0 = {
  // ...
  onProgress: ((e: BlobProgressEvent) => {
    console.log(e)
    // {
    //  "written": <some_number_of_bytes_written>,
    //  "total": <some_total_number_of_bytes>
    // }
  })
};

const fetchedResult = await BlobCourier.fetchBlob(request0);

// ...

// Upload a file
const request1 = {
  // ...
  onProgress: ((e: BlobProgressEvent) => {
    console.log(e)
    // {
    //  "written": <some_number_of_bytes_written>,
    //  "total": <some_total_number_of_bytes>
    // }
  })
};

const uploadResult = await BlobCourier.uploadBlob(request1)

// ...

// Set progress updater interval
const request2 = ...

const someResult =
  await BlobCourier
    .fetchBlob({
      ...request2,
      progressIntervalMilliseconds: 1000,
    });

Managed download on Android (not available on iOS)

import BlobCourier from 'react-native-blob-courier';

// ...

const request = {
  android: {
    useDownloadManager: true // <--- set useDownloadManager to "true"
  },
  filename: '5MB.zip',
  method: 'GET',
  mimeType: 'application/zip',
  url: 'http://ipv4.download.thinkbroadband.com/5MB.zip',
};

const fetchResult = await BlobCourier.fetchBlob(request);

console.log(fetchedResult);
// {
//   "data": {
//     "result": "SUCCESS",
//     "absoluteFilePath": "/path/to/app/cache/5MB.zip"
//   },
//   "type":"Managed"
// }

Multipart upload

Sometimes order of multipart fields matters, and Blob Courier respects the order in which parts are provided. There is a catch though: due to how JavaScript works, when object keys are regular strings they are kept in the order they were added unless the keys are strings containing numbers, e.g.:

Object.keys({
  "b": "some_value1",
  "c": "some_value2",
  "a": "some_value3",
})

// ['b', 'c', 'a']

Object.keys({
  "b": "some_value1",
  "c": "some_value2",
  "a": "some_value3",
  "3": "some_value4",
  "2": "some_value5",
  "1": "some_value6",
});

// ['1', '2', '3', 'b', 'c', 'a']

The way to work around this, is to wrap all keys in a Symbol, by using Symbol.for. Do not use Symbol(<value>), this will not work, e.g.:

Object.getOwnPropertySymbols({
  [Symbol.for("b")]: "some_value1",
  [Symbol.for("c")]: "some_value2",
  [Symbol.for("a")]: "some_value3",
  [Symbol.for("3")]: "some_value4",
  [Symbol.for("2")]: "some_value5",
  [Symbol.for("1")]: "some_value6",
});

// [Symbol('b'), Symbol('c'), Symbol('a'), Symbol('3'), Symbol('2'), Symbol('1')]

Cancel request

import BlobCourier from 'react-native-blob-courier';

// ...

const abortController = new AbortController();

const { signal } = abortController;

const request0 = {
  // ...
  signal,
};

try {
  BlobCourier.fetchBlob(request0);

  abortController.abort();
} catch (e) {
  if (e.code === ERROR_CANCELED_EXCEPTION) {
    // ...
  }
}

// ...

Fluent interface

Blob Courier provides a fluent interface, that both protects you from using impossible setting combinations and arguably improves readability.

const req0 = ...

const someResult =
  await BlobCourier
    .settings({
      progressIntervalMilliseconds: 1000,
    })
    .onProgress((e: BlobProgressEvent) => {
      // ...
    })
    .useDownloadManagerOnAndroid({
      description: "Some file description",
      enableNotification: true,
      title: "Some title"
    })
    .fetchBlob(req0)

Available methods

fetchBlob(input: BlobFetchRequest)

Required

FieldTypeDescription
filenamestringThe name the file will have on disk after fetch.
mimeTypestringWhat is the mime type of the blob being transferred?
urlstringFrom which url will the blob be fetched?

Optional

FieldTypeDescriptionDefault
androidAndroidSettingsSettings to be used on Android{ downloadManager: {}, target: 'cache', useDownloadManager: false }
headers{ [key: string]: string }Map of headers to send with the request{}
iosIOSSettingsSettings to be used on iOS{ target: 'cache' }
headers{ [key: string]: string }Map of headers to send with the request{}
methodstringRepresenting the HTTP methodGET
onProgress(e: BlobProgressEvent) => voidFunction handling progress updates() => { }
signalAbortSignalRequest cancellation managernull

Response

FieldTypeDescription
type"Managed" | "Unmanaged"Was the blob downloaded through Android Download Manager, or without?
dataBlobManagedData | BlobUnmanagedDataEither managed or HTTP response data

uploadBlob(input: BlobUploadRequest)

Alias for:

const someResult =
  await BlobCourier
   // ...
   .uploadParts({
     headers,
     method,
     parts: {
       file:
         payload: {
           absoluteFilePath,
           filename,
           mimeType,
         },
         type: 'file',
       },
     },
     returnResponse,
     url,
   })

Required

FieldTypeDescription
absoluteFilePathstringPath to the file to be uploaded
mimeTypestringMime type of the blob being transferred
urlstringUrl to upload the blob to

Optional

FieldTypeDescriptionDefault
filenamestringMap of headers to send with the request<name part of 'absoluteFilePath'>
headers{ [key: string]: string }Map of headers to send with the request{}
methodstringThe HTTP method to be used in the request"POST"
multipartNamestringName for the file multipart"file"
onProgress(e: BlobProgressEvent) => voidFunction handling progress updates() => { }
returnResponsebooleanReturn the HTTP response body?false
signalAbortSignalRequest cancellation managernull

uploadParts(input: BlobMultipartUploadRequest)

Required

FieldTypeDescription
parts{ [key: string]: BlobMultipart }The parts to be sent
urlstringUrl to upload the blob to

Optional

FieldTypeDescriptionDefault
headers{ [key: string]: string }Map of headers to send with the request{}
methodstringThe HTTP method to be used in the request"POST"
onProgress(e: BlobProgressEvent) => voidFunction handling progress updates() => { }
returnResponsebooleanReturn the HTTP response body?false
signalAbortSignalRequest cancellation managernull

Response

FieldTypeDescription
responseBlobUnmanagedHttpResponseThe HTTP response

AndroidDownloadManagerSettings

FieldTypeDescription
description?stringDescription of the downloaded file
enableNotification?booleanDisplay notification when download completes
title?stringTitle to be displayed with the download

AndroidSettings

FieldTypeDescription
downloadManagerAndroidDownloadManagerSettingsSettings to be used on download manager
target"cache" | "data"Where will the file be stored?
useDownloadManagerbooleanEnable download manager on Android?

BlobManagedData

FieldTypeDescription
absoluteFilePathstringThe absolute file path to where the file was stored
result"SUCCESS" | "FAILURE"Was the request successful or did it fail?

BlobMultipart

Required

FieldTypeDescription
payloadBlobMultipartFormData | BlobMultipartFormDataFileContains the payload of the part
type"string" | "file"What is the type of the payload?

BlobMultipartFormData

Type of string | { [key:string] : any }

BlobMultipartFormDataFile

Required

FieldTypeDescription
absoluteFilePathstringPath to the file to be uploaded
mimeTypestringMime type of the blob being transferred

Optional

FieldTypeDescriptionDefault
filenamestringMap of headers to send with the request<name part of 'absoluteFilePath'>

BlobProgressEvent

FieldTypeDescription
writtennumberNumber of bytes processed
totalnumberTotal number of bytes to be processed

BlobUnmanagedData

FieldTypeDescription
absoluteFilePathstringThe absolute file path to where the file was stored
responseBlobUnmanagedHttpResponseHTTP response, including headers and status code

BlobUnmanagedHttpResponse

FieldTypeDescription
codenumberHTTP status code
headers{ [key: string]: string }HTTP response headers

IOSSettings

FieldTypeDescription
target"cache" | "data"Where will the file be stored?

Example app

You can find an example of how to use the library in the example directory.

Android

Permissions

Android 5.1 and below (API level < 23)

Add the following line to AndroidManifest.xml.

<manifest xmlns:android="http://schemas.android.com/apk/res/android" (...)>

+   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+   <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
    (...)
    <application (...)>
      <activity (...)>
        <intent-filter>
          (...)
+          <action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>
        </intent-filter>
    (...)

Android 6.0+ (API level 23+)

Grant permissions using the PermissionAndroid API, like so:

const function App = () => {

  // ...

  React.useEffect(() => {
    const requestPermissionAsync = async () => {
      try {
        await PermissionsAndroid.request(
          PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE
        );

        // ...
      } catch (err) {
        console.error(err);
      }

      // ...
    };

    requestPermissionAsync();
  }, []);

  // ...

iOS

Add to Info.plist of your app:

<key>NSAllowsArbitraryLoads</key>
<true/>

Using the integrated download manager for Android

This library allows you to use the integrated download manager on Android, this option is not available for iOS.

To enable the download manager, simply set the request's useDownloadManager property of field android to true when passing it to fetchBlob, or call the useDownloadManagerOnAndroid method when using the fluent interface.

Shared directories

As this library is focussed on transferring files, it only supports storage to the app's cache and data directories. To move files from these app specific directories to other locations on the filesystem, use another library like @react-native-community/cameraroll, e.g.:

import BlobCourier from 'react-native-blob-courier';
import CameraRoll from '@react-native-community/cameraroll';

// ...

const request = {
  filename: 'teh_cage640x360.png',
  method: 'GET',
  mimeType: 'image/png',
  url: 'https://www.placecage.com/640/360',
};

const cageResult = await BlobCourier.fetchBlob(request)

const cageLocalPath = cageResult.data.absoluteFilePath

CameraRoll.save(cageLocalPath);

Contributing

See the contributing guide to learn how to contribute to the repository and the development workflow.

Download Details:
Author: edeckers
Source Code: https://github.com/edeckers/react-native-blob-courier
License: MPL-2.0 license

#react  #reactnative  #mobileapp  #javascript  #backend #kotlin #typescript 

How to Download & Upload Blobs In React Native

NPM Package for the Javasript React Native for Nchan

NchanSubscriber.js

A Websocket, EventSource, and Long-Polling wrapper for Nchan

// CommonJS

import NchanSubscriber from 'react-native-nchan'

//options
let opt = {
  subscriber: 'longpoll', 'eventsource', or 'websocket',
    //or an array of the above indicating subscriber type preference
  reconnect: undefined,
  shared: undefined
}

const sub = new NchanSubscriber(url, opt);

sub.on("message", function(message, message_metadata) {
  // message is a string
  // message_metadata is a hash that may contain 'id' and 'content-type'
});

sub.on('connect', function(evt) {
  //fired when first connected.
});

sub.on('disconnect', function(evt) {
  // when disconnected.
});

sub.on('error', function(error_code or evt, error_description) {
  //error callback
});

sub.reconnect; // should subscriber try to reconnect? true by default.
sub.reconnectTimeout; //how long to wait to reconnect? does not apply to EventSource, which reconnects on its own.
sub.lastMessageId; //last message id. useful for resuming a connection without loss or repetition.

sub.start(); // begin (or resume) subscribing
sub.stop(); // stop subscriber. do not reconnect.

Download Details:
Author: indatawetrust
Source Code: https://github.com/indatawetrust/react-native-nchan
License:

#react  #reactnative  #mobileapp  #javascript  #backend 

NPM Package for the Javasript React Native for Nchan

Asynchronous Http Client for React Native (Android)

react-native-async-http

Asynchronous Http Client for Android 

Installation

npm install react-native-async-http@latest --save

Getting started - Android

  • In android/setting.gradle
...
include ':react-native-async-http'
project(':react-native-async-http').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-async-http/android')
  • In android/app/build.gradle
...
dependencies {
    ...
    compile project(':react-native-async-http')
}
  • register module (in MainActivity.java)
import com.smccz.asynchttp.AsyncHttpAndroidPackage; // <--- import

public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
  ......

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mReactRootView = new ReactRootView(this);

    mReactInstanceManager = ReactInstanceManager.builder()
      .setApplication(getApplication())
      .setBundleAssetName("index.android.bundle")
      .setJSMainModuleName("index.android")
      .addPackage(new MainReactPackage())
      .addPackage(new AsyncHttpAndroidPackage())         // <------ add here
      .setUseDeveloperSupport(BuildConfig.DEBUG)
      .setInitialLifecycleState(LifecycleState.RESUMED)
      .build();

    mReactRootView.startReactApplication(mReactInstanceManager, "example", null);

    setContentView(mReactRootView);
  }

  ......

}

Download Details:
Author: szq4119
Source Code: https://github.com/szq4119/react-native-async-http
License:

#react #reactnative  #mobileapp  #javascript  #backend #java 

Asynchronous Http Client for React Native (Android)

SSDP Client & Server to Use in Your React-native Apps

SSDP fork for React Native from node

This is a fork of node-ssdp that uses react-native-udp instead of dgram to enable react multicast messaging and plain socket control. The API is the same as in the forked version. 

 This package powers Yeti Smart Home and is used in production. It is maintained with our developers's free time, PRs and issues are more than welcome.

Installation

Unless React Native Version is > 0.29 use rnpm else use react-native link.

npm install react-native-ssdp
rnpm link

Make sure you set Buffer as global in react-native-udp's UdpSockets.js (noted filename end with letter s)

global.Buffer = global.Buffer || require('buffer').Buffer

Things to take note

Be aware that the Android emulator does not support incoming UDP traffic, so the client will not get any responses to search requests. For best results, test on a real device when using Android. The iOS simulator, on the other hand, works just fine.

Make sure you close all the sockets you open and never try to reopen one already open, mobile OSs and React Native are very aggresive both with security and performance, so a misuse could kill your process.

Usage (Android)

android/settings.gradle

...
include ':react-native-udp'
project(':react-native-udp').projectDir = new File(settingsDir, '../node_modules/react-native-udp/android')
include ':react-native-network-info'
project(':react-native-network-info').projectDir = new File(settingsDir, '../node_modules/react-native-network-info/android')

android/app/build.gradle

...
dependencies {
    ...
    compile project(':react-native-udp')
    compile project(':react-native-network-info')
}

register module in MainActivity.java

For RN 0.19.0 and higher

import com.tradle.react.UdpSocketsModule;  // <--- import
import com.pusherman.networkinfo.RNNetworkInfoPackage; // <--- import

public class MainActivity extends ReactActivity {
   // ...
    @Override
    protected List<ReactPackage> getPackages() {
      return Arrays.<ReactPackage>asList(
        new MainReactPackage(), // <---- add comma
        new UdpSocketsModule(), // <---- add package
        new RNNetworkInfoPackage() // <---------- add package
      );
    }

For react-native 0.29.0 and higher ( in MainApplication.java )

import com.tradle.react.UdpSocketsModule;  // <--- import
import com.pusherman.networkinfo.RNNetworkInfoPackage; // <--- import

public class MainApplication extends Application implements ReactApplication {
   // ...
    @Override
    protected List<ReactPackage> getPackages() {
      return Arrays.<ReactPackage>asList(
        new MainReactPackage(), // <---- add comma
        new UdpSocketsModule(), // <---- add package
        new RNNetworkInfoPackage() <---- add package
      );
    }

Usage (iOS)

Adding with CocoaPads

Add the RNFS pod to your list of applications pods in your podfile, using the path from the Podfile to the installed module.

pod 'RNUDP', :path => './node_modules/react-native-udp'
pod 'RNNetworkInfo', :path => './node_modules/react-native-network-info'

Install pods as usual:

pod install

Adding manually in Xcode

In XCode, in the project navigator, right click Libraries ➜ Add Files to [your project's name] Go to node_modules ➜ react-native-fs and add the .xcodeproj file

In XCode, in the project navigator, select your project. Add the lib*.a from the RNFS project to your project's Build Phases ➜ Link Binary With Libraries. Click the .xcodeproj file you added before in the project navigator and go the Build Settings tab. Make sure 'All' is toggled on (instead of 'Basic'). Look for Header Search Paths and make sure it contains both $(SRCROOT)/../react-native/React and $(SRCROOT)/../../React - mark both as recursive.

Run your project (Cmd+R)

Note: Library uses these installed native_modules internally for sockets communication.

Usage - Client

    var Client = require('react-native-ssdp').Client
      , client = new Client();

    client.on('response', function (headers, statusCode, rinfo) {
      console.log('Got a response to an m-search.');
    });

    // search for a service type
    client.search('urn:schemas-upnp-org:service:ContentDirectory:1');

    // Or get a list of all services on the network

    client.search('ssdp:all');

Usage - Server

    var Server = require('react-native-ssdp').Server
      , server = new Server()
    ;

    server.addUSN('upnp:rootdevice');
    server.addUSN('urn:schemas-upnp-org:device:MediaServer:1');
    server.addUSN('urn:schemas-upnp-org:service:ContentDirectory:1');
    server.addUSN('urn:schemas-upnp-org:service:ConnectionManager:1');

    server.on('advertise-alive', function (headers) {
      // Expire old devices from your cache.
      // Register advertising device somewhere (as designated in http headers heads)
    });

    server.on('advertise-bye', function (headers) {
      // Remove specified device from cache.
    });

    // start the server
    server.start();

    process.on('exit', function(){
      server.stop() // advertise shutting down and stop listening
    })

Legacy docs from the forked repo

Take a look at example directory as well to see examples or client and server.

##Configuration new SSDP([options, [socket]])

SSDP constructor accepts an optional configuration object and an optional initialized socket. At the moment, the following is supported:

  • ssdpSig String SSDP signature. Default: node.js/NODE_VERSION UPnP/1.1 node-ssdp/PACKAGE_VERSION
  • ssdpIp String SSDP multicast group. Default: 239.255.255.250.
  • ssdpPort Number SSDP port. Default: 1900
  • ssdpTtl Number Multicast TTL. Default: 1
  • adInterval Number advertise event frequency (ms). Default: 10 sec.
  • unicastHost String IP address or hostname of server where SSDP service is running. This is used in HOST header. Default: 0.0.0.0.
  • location String URL pointing to description of your service, or a function which returns that URL
  • udn String Unique Device Name. Default: uuid:f40c2981-7329-40b7-8b04-27f187aecfb5.
  • description String Path to description file. Default: upnp/desc.php.
  • ttl Number Packet TTL. Default: 1800.
  • allowWildcards Boolean Accept wildcards (*) in serviceTypes of M-SEARCH packets, e.g. usn:Belkin:device:**. Default: false

###Logging

You can enable logging via an environment variable DEBUG. Set DEBUG=node-ssdp* to enable all logs. To enable only client or server logs, use DEBUG=node-ssdp:client or DEBUG=node-ssdp:server respectively.

Download Details:
Author: netbeast
Source Code: https://github.com/netbeast/react-native-ssdp
License:

#react  #reactnative  #mobileapp  #javascript  #backend 

SSDP Client & Server to Use in Your React-native Apps

Sync Between React Native Realmjs Databases

react-native-sync

Two way, incremental sync between React Native realmjs databases and MySQL, Oracle, MS SQL Server and PostgreSQL databases.

Features

  • Direct DB synchronization between on device realmjs DB and server side MySQL, Oracle, MS SQL Server and PostgreSQL databases
  • Each user could subscribe to a subset of server side data
  • Files can also be syned

Setup

For end-to-end testing, you need to first setup a Pervasync server and publish your central database tables for sync. See Pervasync documentation for instructions.

This library is available on npm, install it with: npm install --save react-native-sync or yarn add react-native-sync.

Usage

  1. Import react-native-sync as RNSync:
import RNSync from "react-native-sync";

2.   Configure RNSync:

var settings = {
    syncServerUrl: "http://localhost:8080/pervasync/server", // required
    syncUserName: "user_1", // required
    syncUserPassword: "welcome1", // required
};
await RNSync.config(settings);

3.   Start a sync session:

let syncSummary = await RNSync.sync();

4.   Get a handle to the synced realm database and synced folder path:

let realm = await RNSync.getRealm(syncSchemaName);
let path = await RNSync.getPath(syncFolderName);

Complete Example

Check out react-native-sync-demo and expecially sync.js

Download Details:
Author: pervasync
Source Code: https://github.com/pervasync/react-native-sync
License: MIT license

#react  #reactnative  #mobileapp  #javascript  #backend #postgresql #mysql 

Sync Between React Native Realmjs Databases

A React Native Version Of Backbone Model

react-native-backbone

As react native does not support Node.js HTTP module, react-native-backbone helps you to connect to your REST api or localStorage much easier using the same concept of Backbone models and collections.

  • You can simply call "save", "fetch", "destroy" method on each model to sycn them to your REST api.
  • "fetch" collections from REST api.
  • Using model.get() to retrieve data from model
  • Add an extra layer of the fetch method to check if the status API returns is not 200. Returns an json file instead of response object.

To do:

  • syncronize with localStorage

Install

The easiest way to install: npm install react-native-backbone

And require it in your React Native app: var RNBackbone = require('react-native-backbone'); or ES6: import RNBackbone from 'react-native-backbone';

RNBackbone.Model

RNBackbone.Model is extended from backbone. The usages is almost the same as Backbone.Model, but some methods might be differnt.

Create a model class

var Car = RNBackbone.Model.extend({
    rootUrl: "http://www.your-domain.com/car"
    //More options to be added
});

rootUrl: the root url where this model connects to.

  • value: String or function. If its a function it should return a string.

Create an instance

var bmw = new Car({
    "make": "BMW",
    "model": "428i",
    "year": 2014
})

You can create a model using the new keyword. You can pass an object as the initial value of the model, you can also create an empty model.

Model methods:

set():

bmw.set('mpg', '23')

this will set the atrribute mpg to 23.

  • If the attribute does not exist, this attribute will be added to the model.
  • If the attribute does exist, the value will be replaced.

You can also pass a json object as the argument:

bmw.set({
    "mpg": 23,
    "color": "white"
})

unset():

bmw.unset('mpg', '23')

The attribute "mpg" will be deleted

  • Unset does not take json object or array as argument.

isNew():

bmw.isNew();

This will return ture if "id" attribute does not exist

save():

var option = {
    headers:{
        "Authentication":"Bearer SOME_TOKEN"
    }
}

bmw.save(option, function(error){
    if(error) console.log(error);
    console.log(people);
});

Save this model to the server, this is POST for new model and PUT for existing model

  • option: (optional)

** option.headers: the headers to be added to the HTTP request

fetch():

bmw = new Car({
    id: 1
});

bmw.fetch(function(error){
    if(error) console.log(error);
    console.log(people);
});

Fetch this model from the server, this is GET request

  • To fetch an model, ID has to be set.
  • option: (optional)

** option.headers: the headers to be added to the HTTP request

delete():

bmw.delete(option, function(error){
    if(error) console.log(error);
});

Delete this model to the server, this is DELETE method

  • To delete an model, ID has to be set.
  • option: (optional)

** option.headers: the headers to be added to the HTTP request

RNBackbone.Collection

There is only one sync method supported for collection: fetch

var Cars = RNBackbone.Colletion.extend({
    model: Car,
    url: 'https://YOUR_URL/cars
});
var cars = new Cars();
cars.fetch({
    success: ()=>{
        console.log(cars);
    }
})

Storage

As of react-native-backbone 0.1.0, we provides two different storage connectors.

fetchStorage

fetchStorage is the default storage connectors used by RNBackbone. It uses the built-in "fetch" method of React-Native

fetchStorage.globalOption.headers

If you want to send some headers in every request, you can set it up here.

import fetchStorage from 'react-native-backbone/src/storages/fetch'
fetchStorage.globalOption.headers:{
    "Authentiacation":"Bearer SOME_TOKEN"
}

fetchStorage.send()

Send simple HTTP request This is based on the React Native fetch method. It has a simple error checking to check if the response status is not between 200-208 or 226. The returned object is a json instead of a response object

//Set up request object
var request = {
    method: 'post',
    headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "app":"FM Business",
        "platform":"iOS"
    })
}

var url = 'https://maps.googleapis.com/maps/api/geocode/json?address=1600+Amphitheatre+Parkway,+Mountain+View,+CA';

fetchStorage.send(url, request, function(error, json){
                if(error)
                    console.log("encountered error: ", error);
                console.log(json);
            });

request object: the same object used for fetch()

Realm

React Native's "asycnStorage" is a key-value pair storage, which is not ideal for the backbone concept. react native backbone uses a JavaScript library Realm for local storage

Setting up Realm

  • RNBackbone has declared Realm as its dependency. But if you plan to use Realm in your project, you have to set it up using rnpm: rpm link realm
  • Then you have to config RNBackbone to use Realm:
import RNBackbone from 'react-native-backbone';
import realmStorage from 'react-native-backbone/src/storages/realm';
RNBackbone.storage = realmStroage;
  • Realm requires you to declare the schema of each Models before using them:
	const CarSchema = {
	  name: 'Car',
	  properties: {
		 make:  'string',
		 model: 'string',
		 miles: {type: 'int', default: 0},
	  }
   }; 

Realm doc about models: https://realm.io/docs/react-native/latest/#models

Initialize realmStorage:

realmStorage.init({
  models: [Car, People]
});

Now you can start using RNBackbone as normal

Realm Filter

If you are fetching a collection and you want to filter the objects, you can pass the filter option to the fetch method:

var Cars = RNBackbone.Colletion.extend({
    model: Car,
    url: 'https://YOUR_URL/cars
});
var cars = new Cars();
cars.fetch({
    filters: {
        make: 'bmw'
    },
    success: ()=>{
        console.log(cars);
    }
})

Download Details:
Author: peter4k
Source Code: https://github.com/peter4k/react-native-backbone
License:

#react  #reactnative  #mobileapp  #javascript  #backend #objective-c 

A React Native Version Of Backbone Model

React Native Module to Download and Upload Files

react-native-networking

A react-native module to download and upload files on iOS and Android.

Installation

Installation (iOS)

Assuming you're using cocoapods to manage your iOS dependencies, add react-native-networking as a new dependency:

# Podfile
pod 'react-native-networking', :path => '../node_modules/react-native-networking'

then run pod install and you're good to go!

Installation (Android)

  • In android/setting.gradle
...
include ':RNNetworkingManager', ':app'
project(':RNNetworkingManager').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-networking/android')
  • In android/app/build.gradle
...
dependencies {
    ...
    compile project(':RNNetworkingManager')
}
  • register module (in MainActivity.java)
import com.learnium.RNNetworkingManager.*;  // <--- import

public class MainActivity extends Activity implements DefaultHardwareBackBtnHandler {
  ......

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mReactRootView = new ReactRootView(this);

    mReactInstanceManager = ReactInstanceManager.builder()
      .setApplication(getApplication())
      .setBundleAssetName("index.android.bundle")
      .setJSMainModuleName("index.android")
      .addPackage(new MainReactPackage())
      .addPackage(new RNNetworkingManagerModule())              // <------ add here
      .setUseDeveloperSupport(BuildConfig.DEBUG)
      .setInitialLifecycleState(LifecycleState.RESUMED)
      .build();

    mReactRootView.startReactApplication(mReactInstanceManager, "ExampleRN", null);

    setContentView(mReactRootView);
  }

  ......

}

Android Limitations

Android currently only supports downloading at the moment.

Usage

In your react-native project, require the module:


var RNNetworkingManager = require('react-native-networking');
var url = 'localhost:3000';

// Example GET request, (download)
RNNetworkingManager.requestFile(url, {
    'method':'GET'
}, function(results) {
  console.log(results);
});

// Example POST request, (upload)
RNNetworkingManager.requestFile(url, {
    'method': 'POST',
    'data' : 'pathToYourFileHere'
}, function(results) {
    console.log(results);
});

The GET request automatically downloads the file to the Documents/ in your app. Similarly, the POST request automatically uploads from Documents/ of your app.

Please feel free to open issues and contribute.

Download Details:
Author: eduedix
Source Code: https://github.com/eduedix/react-native-networking
License: MIT license

#react  #reactnative  #mobileapp  #javascript  #backend 

React Native Module to Download and Upload Files

A Plugin for File Upload on React Native

react-native-file-upload

React Native latest version had support file upload, the package is deprecated, detail see #4 #7.

A file upload plugin for react-native written by Objective-C.

  • Support to upload multiple files at a time
  • Support to files and fields

Getting started

  1. npm install react-native-file-upload --save
  2. In XCode, in the project navigator, right click your projectAdd Files to [your project's name]
  3. Go to node_modulesreact-native-file-upload and add FileUpload.m
  4. Run your project (Cmd+R)

Usage

All you need is to export module var FileUpload = require('NativeModules').FileUpload; and direct invoke FileUpload.upload.

'use strict';

var React = require('react-native');
var FileUpload = require('NativeModules').FileUpload;

var {
  AppRegistry,
  StyleSheet,
  Text,
  View,
} = React;

var FileUploadDemo = React.createClass({
  componentDidMount: function() {
    var obj = {
        uploadUrl: 'http://127.0.0.1:3000',
        method: 'POST', // default 'POST',support 'POST' and 'PUT'
        headers: {
          'Accept': 'application/json',
        },
        fields: {
            'hello': 'world',
        },
        files: [
          {
            name: 'one', // optional, if none then `filename` is used instead
            filename: 'one.w4a', // require, file name
            filepath: '/xxx/one.w4a', // require, file absoluete path
            filetype: 'audio/x-m4a', // options, if none, will get mimetype from `filepath` extension
          },
        ]
    };
    FileUpload.upload(obj, function(err, result) {
      console.log('upload:', err, result);
    })
  },
  render: function() {
    return (
      <View style={styles.container}>
        <Text style={styles.welcome}>
          Welcome to React Native!
        </Text>
      </View>
    );
  }
});

var styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#F5FCFF',
  },
  welcome: {
    fontSize: 20,
    textAlign: 'center',
    margin: 10,
  },
});

AppRegistry.registerComponent('FileUploadDemo', () => FileUploadDemo);

Download Details:
Author: booxood
Source Code: https://github.com/booxood/react-native-file-upload
License: MIT license

#react  #reactnative  #mobileapp  #javascript  #backend 

A Plugin for File Upload on React Native