Skuy

If AfterJS and RogueJS had a baby...

NextJS beloved grandchild..

Getting started with Skuy

Skuy has same API as After.js.

If you have familiarize yourself with After, then you are not finding it difficult to migrate to Skuy.

Also : You can build it on your SSR boilerplate (either it webpack, parcel, etc).

Skuy is just another component wrapper to ease React SSR.

Quickstart with Razzle

curl https://codeload.github.com/rayandrews/skuy/tar.gz/master | tar -xz --strip=2 skuy-master/examples/basic
cd basic

Background

After is awesome library but it has some drawbacks that I found it difficult to modify it in my other projects such as,

Not able to modify routes tree
Not able to modify static method for get initial props (getInitialProps is good, but you should be able to modify the name based on your content)
Not able to add loading or error component while transitioning and getting initial props for other route
Code splitting and load inital props based on routes config

How about Rogue?

Brilliant Idea to walk into react tree component recursively like Apollo did in their library

But.. something is bothering me..

Document feature in Next and After is REALLY syntactic sugar
GetInitialProps method only called on top highest level component (for performance, I know)
And of course, not be able to modify static method too

tl;dr
I found them not too suitable for my works

Table of Contents

How Skuy Works

Skuy will walk through your React Tree to find static method that you've already specified.

If Skuy not found any static method, Skuy will gracefully return your rendered component.

Data Fetching

For now, in all components that you want to fetch, you can add a static async getInitialProps or another function's name that exactly does the same. This will be called on both initial server render, and then client mounts.

Results are made available on the CONTEXT NOT ON PROPS

If you want to get data in the props, you must include the skuyHoc to easily passing data from context to props.

OR

Use SkuyConsumer (React ^16) to consume the data.

// Home.js
import React from 'react';
import { NavLink } from 'react-router-dom';

class Home extends React.Component {
  static async getInitialProps({ req, res, match }) {
    const stuff = await CallMyApi();
    return { stuff }; // returned value from static method not passed on props by default
  }

  render() {
    return (
      <div>
        <NavLink to="/about">About</NavLink>
        <h1>Home</h1>
      </div>
    );
  }
}

export default Home;

`getInitialProps | { name } : (ctx) => object`

Within getInitialProps or another function name, you will get access to all you need to fetch data on both the client and the server (same like After)

req?: Request: (server-only) A Express.js request object
res?: Request: (server-only) An Express.js response object
match: React Router 4's match object.
history: React Router 4's history object.
location: (client-only) React Router 4's location object.
isServer: Check whether code is running on server or client

You can also add another variable to be passed into static method like Redux Store, etc.

If you are using some server only modules inside getInitialProps or anoher function name, make sure to import them properly. Otherwise, it'll slow down your app.

Taken from Next

Injected Context Data

data: any - Whatever you have returned in getInitialProps or another function name
loading: boolean - Loading state while fetching data in client
error: boolean - Error state (but not throwing error) while fetching data in client
prefetch: (pathname: string) => void - Imperatively prefetch and cache data for a path.

// Home.js
import React from 'react';
import { NavLink } from 'react-router-dom';
import { SkuyConsumer } from 'skuy/core';

class Home extends React.Component {
  static async getInitialProps({ req, res, match }) {
    const stuff = await CallMyApi();
    return { stuff };
  }

  render() {
    return (
      <div>
        <NavLink to="/about">About</NavLink>
        <h1>Home</h1>
        <SkuyConsumer>
          {({ data, loading }) => (
            if(loading) return <div>'Loading...'</div>;

            return data.stuff;
          )}
        </SkuyConsumer>
      </div>
    );
  }
}

export default Home;

OR

Using skuyHoc to wrap your context into props, just like Redux connect.

You can also pass options like LoadingComponent and ErrorComponent to reduce boilerplate in your render function.

skuyHoc : ({ LoadingComponent?: null, ErrorComponent?: null }) => (Component) => WrappedComponent

TL;DR All static methods will be hoisted

// Home.js
import React from 'react';
import { NavLink } from 'react-router-dom';
import { skuyHoc } from 'skuy/core';

class Home extends React.Component {
  static async getInitialProps({ req, res, match }) {
    const stuff = await CallMyApi();
    return { stuff };
  }

  render() {
    return (
      <div>
        <NavLink to="/about">About</NavLink>
        <h1>Home</h1>
        <div>{this.props.data.stuff}</div>
      </div>
    );
  }
}

export default skuyHoc({
  LoadingComponent: () => <div>Loading...</div>,
  ErrorComponent: () => <div>Error!</div>
})(Home);

Routing

React Router 4 is used in all over Skuy API.

Custom Options

Examples

Basic with React Native Web

Skuy does not need any router config, so just passing React component with React Router 4 in it, and you're done!

Skuy has default options as follows

{
  document = DefaultSkuyDocument,
  staticMethod = 'getInitialProps',
  rootId = 'root',
  dataId = 'server-app-state',
}

If you want to change static method, rootId, and dataId, you must pass it both in client and server

Example

Skuy : ({ component, data, options }) => RenderedComponent

// client.js

import React from 'react';
import { hydrate } from 'react-dom';
import { BrowserRouter } from 'react-router-dom';
import './client.css';

import { Skuy } from 'skuy/core';
import { getSsrData } from 'skuy/client';
import App from './App';

const data = getSsrData();
const options = {
  staticMethod: 'fetchData', // * change the method to make client can preload data

  // Anything else you add here will be made available
  // within static method in client
  // e.g a redux store, etc.
}

hydrate(
  <BrowserRouter>
    <Skuy component={App} data={data} options={options} />
  </BrowserRouter>,
  document.getElementById('root')
);

if (module.hot) {
  module.hot.accept();
}

render : (component = App, routerContext, options) => html : string

// server.js

import express from 'express';
import { render } from 'skuy/server';

import App from './App';

const assets = require(process.env.RAZZLE_ASSETS_MANIFEST);

const server = express();
server
  .disable('x-powered-by')
  .use(express.static(process.env.RAZZLE_PUBLIC_DIR))
  .get('/*', async (req, res) => {
    const routerContext = {};

    if (req.url.match(/.map$/)) return;

    try {
      const html = await render(App, routerContext, {
        req,
        res,
        assets,
        staticMethod: 'fetchData',
        customThing: 'thing',

        // Anything else you add here will be made available
        // within static method in server
        // e.g a redux store, etc.
      });
      res.send(html);
    } catch (error) {
      res.json(error);
    }
  });

export default server;

Code Splitting

Examples

Skuy does not defining any code splitting method like After, Next, or Rogue (with loadable-components) did.

But Skuy does enforce you to implement code splitting with other libraries

With the right custom render function, you can implement it with another React code splitting library out there such as

Custom Document

Examples

Skuy works like After and Next, you can override any html structure that suitable for your needs.

Why we need it?

It really helps if you want to add CSS or other component with side-effects (React Helmet, etc) that needs custom document structure.

Example with React Native Web

import React, { Component } from 'react';
import { AppRegistry } from 'react-native';
import { renderToStaticMarkup } from 'react-dom/server';

import { SkuyRoot, SkuyData } from 'skuy/document';

/* eslint-disable */

export default class CustomDocument extends Component {
  static async getInitialProps({ assets, data, renderPage }) {
    const page = await renderPage();

    AppRegistry.registerComponent('SkuyRoot', () => SkuyRoot);
    const { getStyleElement } = AppRegistry.getApplication('SkuyRoot', {});

    const rnwCss = renderToStaticMarkup(getStyleElement());

    return { assets, data, rnwCss, ...page };
  }

  render() {
    const {
      rootId,
      dataId,
      helmet,
      assets,
      data,
      rnwCss,
    } = this.props;

    const htmlAttrs = helmet.htmlAttributes.toComponent();
    const bodyAttrs = helmet.bodyAttributes.toComponent();

    return (
      <html lang="en" {...htmlAttrs}>
        <head>
          <meta httpEquiv="X-UA-Compatible" content="IE=edge" />
          <meta charSet="utf-8" />
          <meta name="viewport" content="width=device-width, initial-scale=1" />
          {helmet.title.toComponent()}
          {helmet.meta.toComponent()}
          {helmet.link.toComponent()}
          {assets.client.css && (
            <link rel="stylesheet" href={assets.client.css} />
          )}
          <style
            id="react-native-stylesheet"
            dangerouslySetInnerHTML={{
              __html: rnwCss
                .replace(/<\/style>/g, '')
                .replace(/<style id="react-native-stylesheet">/g, ''),
            }}
          />
        </head>
        <body {...bodyAttrs}>
          <SkuyRoot id={rootId} />
          <SkuyData id={dataId} data={data} />
          <script
            type="text/javascript"
            src={assets.client.js}
            crossOrigin="anonymous"
          />
        </body>
      </html>
    );
  }
}

If you were using something like styled-components, and you need to wrap you entire app with some sort of additional provider or function, you can do this with renderPage().

Taken from After

// Document.js
import React, { Component } from 'react';
import { ServerStyleSheet } from 'styled-components'
import { renderToStaticMarkup } from 'react-dom/server';

import { SkuyRoot, SkuyData } from 'skuy/document';

export default class CustomDocument extends Component {
  static async getInitialProps({ assets, data, renderPage }) {
    const sheet = new ServerStyleSheet();
    const page = await renderPage(App => props => sheet.collectStyles(<App {...props} />));
    const styleTags = sheet.getStyleElement();
    return { assets, data, ...page, styleTags };
  }

  render() {
    const {
      rootId,
      dataId,
      helmet,
      assets,
      data,
      styleTags,
    } = this.props;
    const htmlAttrs = helmet.htmlAttributes.toComponent();
    const bodyAttrs = helmet.bodyAttributes.toComponent();

    return (
      <html lang="en" {...htmlAttrs}>
        <head>
          <meta httpEquiv="X-UA-Compatible" content="IE=edge" />
          <meta charSet="utf-8" />
          <meta name="viewport" content="width=device-width, initial-scale=1" />
          {helmet.title.toComponent()}
          {helmet.meta.toComponent()}
          {helmet.link.toComponent()}
          {styleTags}
        </head>
        <body {...bodyAttrs}>
          <SkuyRoot id={rootId} />
          <SkuyData id={dataId} data={data} />
          <script
            type="text/javascript"
            src={assets.client.js}
            defer
            crossOrigin="anonymous"
          />
        </body>
      </html>
    );
  }

To use custom document, you need to pass it on server file

// server.js

import express from 'express';
import { render } from 'skuy/server';

import App from './App';
import Doc from './Document';

const assets = require(process.env.RAZZLE_ASSETS_MANIFEST);

const server = express();
server
  .disable('x-powered-by')
  .use(express.static(process.env.RAZZLE_PUBLIC_DIR))
  .get('/*', async (req, res) => {
    const routerContext = {};

    if (req.url.match(/.map$/)) return;

    try {
      const html = await render(App, routerContext, {
        req,
        res,
        assets,
        staticMethod: 'fetchData',
        customThing: 'thing',
        document: Doc,
        // Anything else you add here will be made available
        // within static method in server
        // e.g a redux store, etc.
      });
      res.send(html);
    } catch (error) {
      res.json(error);
    }
  });

export default server;

Custom/Async Rendering

Examples

You can provide a custom (potentially async) rendering function as an option to Skuy render function, just like After.js.

If it presents, it will be used instead of the default ReactDOMServer renderToString function.

It has to return an object of shape { html : string!, ...otherProps }, in which html will be used as the rendered string.

otherProps will be passed as props to the rendered Document.

defaultRenderer = (node) => ({ html: ReactDOMServer.renderToString(node) })

Example

// server.js

import express from 'express';
import { render } from 'skuy/server';

import { Capture } from 'react-loadable';
import { getBundles } from 'react-loadable/webpack';

import stats from 'build/react-loadable.json';

import configureStore from 'store/configureStore';

import App from './App';
import Doc from './Document';

const assets = require(process.env.RAZZLE_ASSETS_MANIFEST);

const server = express();
server
  .disable('x-powered-by')
  .use(express.static(process.env.RAZZLE_PUBLIC_DIR))
  .get('/*', async (req, res) => {
    const routerContext = {};

    if (req.url.match(/.map$/)) return;

    try {
      const preloadedState = {};
      const store = configureStore(preloadedState);
      const modules = [];

      const customRenderer = (node) => {
        const CustomApp = (
          <Capture report={(moduleName) => modules.push(moduleName)}>
            <Provider store={store}>{node}</Provider>
          </Capture>
        );

        const bundles = getBundles(stats, modules);
        const chunks = bundles.filter((bundle) => bundle.file.endsWith('.js'));

        return {
          chunks,
          store, // notice that this will passed into document
          html: renderToString(CustomApp),
        };
      };

      const html = await render(App, routerContext, {
        req,
        res,
        assets,
        staticMethod: 'fetchData',
        customThing: 'thing',
        document: Doc,
        store, // this will be passed in static method in server

        // Anything else you add here will be made available
        // within static method in server
        // e.g a redux store, etc.
      });
      res.send(html);
    } catch (error) {
      res.json(error);
    }
  });

export default server;

Authors

Ray Andrew @rayandrews
Natan Elia @natanelia

Special Thanks

Ivana Irene @ivanaairenee
Reinaldo Ignatius @nimitz21

Inspirations

License

This project is licensed under the MIT License - see the LICENSE.md file for details

Name		Name	Last commit message	Last commit date
Latest commit History 18 Commits
assets		assets
examples		examples
packages/skuy		packages/skuy
.eslintrc		.eslintrc
.gitignore		.gitignore
.prettierrc		.prettierrc
LICENSE.md		LICENSE.md
README.md		README.md
jsconfig.json		jsconfig.json
lerna.json		lerna.json
package.json		package.json

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Skuy

If AfterJS and RogueJS had a baby...

NextJS beloved grandchild..

Getting started with Skuy

Quickstart with Razzle

Background

tl;dr
I found them not too suitable for my works

How Skuy Works

Data Fetching

Results are made available on the CONTEXT NOT ON PROPS

If you want to get data in the props, you must include the skuyHoc to easily passing data from context to props.

OR

Use SkuyConsumer (React ^16) to consume the data.

`getInitialProps | { name } : (ctx) => object`

Injected Context Data

OR

Routing

Custom Options

If you want to change static method, rootId, and dataId, you must pass it both in client and server

Code Splitting

Custom Document

Custom/Async Rendering

Authors

Special Thanks

Inspirations

License

About

Releases

Packages

Languages

License

rayandrew/skuy

Folders and files

Latest commit

History

Repository files navigation

Skuy

If AfterJS and RogueJS had a baby... NextJS beloved grandchild..

Getting started with Skuy

Quickstart with Razzle

Background

tl;dr I found them not too suitable for my works

How Skuy Works

Data Fetching

Results are made available on the CONTEXT NOT ON PROPS If you want to get data in the props, you must include the skuyHoc to easily passing data from context to props.

OR

Use SkuyConsumer (React ^16) to consume the data.

getInitialProps | { name } : (ctx) => object

Injected Context Data

OR

Routing

Custom Options

If you want to change static method, rootId, and dataId, you must pass it both in client and server

Code Splitting

Custom Document

Custom/Async Rendering

Authors

Special Thanks

Inspirations

License

About

Topics

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

If AfterJS and RogueJS had a baby...

NextJS beloved grandchild..

tl;dr
I found them not too suitable for my works

Results are made available on the CONTEXT NOT ON PROPS

If you want to get data in the props, you must include the skuyHoc to easily passing data from context to props.

`getInitialProps | { name } : (ctx) => object`

Packages