import SocketClusterClient from 'socketcluster-client';

let socket = SocketClusterClient.create({
  hostname: 'localhost',
  port: 8000
});

socket.transmit('foo', 123);

(async () => {
  let channel = socket.subscribe("foo");
  for await (let data of channel) {
    console.log("forawait -> data", data);
  }
})();

(async () => {
  for await (let { socket } of agServer.listener("connection")) {

    (async () => {
      for await (let data of socket.receiver('foo')) {
        console.log("forawait -> data", data)
      }
    })();
  }
})();

const connectionConsumerA = agServer.listener('connection').createConsumer();
const connectionConsumerB = agServer.listener('connection').createConsumer();

(async () => {
  for await (let {socket} of connectionConsumerA) {
    console.log(`Consumer ${connectionConsumerA.id} handled connection: ${socket.id}`);
  }
})();

(async () => {
  for await (let {socket} of connectionConsumerB) {
    console.log(`Consumer ${connectionConsumerB.id} handled connection: ${socket.id}`);
  }
})();

setTimeout(() => {
  // Kill only connectionConsumerA.
  connectionConsumerA.kill();
}, 1000);

(async () => {
  for await (let {socket} of agServer.listener('connection')) {

    (async () => {
      console.log('doSomethingWhichTakesAFewSeconds', socket.id)

      for await (let data of socket.receiver('foo')) {
        console.log("forawait -> data", data)
        // ...
      }
    })();

  }
})();

const sleep = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log('doSomethingWhichTakesAFewSeconds');
      resolve();
    }, 1000)
  });
}
(async () => {
  for await (let {socket} of agServer.listener('connection')) {

    (async () => {
      await sleep();

      for await (let data of socket.receiver('foo')) {
        console.log("forawait -> data", data)
      }
    })();

  }
})();

let socket = socketClusterClient.create();

for await (let event of socket.listener('connect')) {
  socket.transmit('foo', 123);
}

(async () => {
  for await (let {socket} of agServer.listener('connection')) {

    (async () => {
      // This will not work because the iterator is not yet created at this point.
      let fooStream = socket.receiver('foo');

      // If any messages arrive during this time, they will be ignored!
      await doSomethingWhichTakesAFewSeconds();

      // The iterator gets created (and starts buffering) here!
      for await (let data of fooStream) {
        // ...
      }
    })();

  }
})();

(async () => {
  for await (let {socket} of agServer.listener('connection')) {

    (async () => {
      // This will create a consumable which will start buffering messages immediately.
      let fooStreamConsumable = socket.receiver('foo').createConsumer();

      await sleep();

      // This loop will start from the beginning of the buffer.
      for await (let data of fooStreamConsumable) {
        console.log("forawait -> data", data)
      }
    })();

  }
})();

;(async () => {
  for await (let requestData of httpServer.listener('request')) {
    expressApp.apply(null, requestData)
  }
})()

;(async () => {
  for await (let { socket } of agServer.listener('connection')) {
    console.log('forawait -> socket.id', socket.id)
    // Handle socket connection.
  }
})()

// SocketCluster/WebSocket connection handling loop.
;(async () => {
  for await (let { socket } of agServer.listener('connection')) {
    console.log(
      'forawait -> socket.id',
      socket.id
    )(
      // Handle socket connection.
      async () => {
        // Set up a loop to handle remote transmitted events.
        for await (let data of socket.receiver('helloworld')) {
          try {
            console.warn('forawait -> helloworld -> data', data)
          } catch (error) {
            console.log('forawait -> error.message', error.message)
          }          
        }
      }
    )()
  }
})()

setTimeout(() => {
  socket.transmit('helloworld', 123)
}, 1000)

;(async () => {
  // Set up a loop to handle and respond to RPCs.
  for await (let request of socket.procedure('customProc')) {
    try {
      if (request.data && request.data.bad) {
        let badCustomError = new Error('Server failed to execute the procedure')
        badCustomError.name = 'BadCustomError'
        throw badCustomError
      }
      request.end('Success')
    } catch (error) {
      console.log('forawait -> customProc -> error.message', error.message)
      request.error(error)
    }
  }
})()

(async () => {
  let channel = socket.subscribe('foo');
  for await (let data of channel) {
    // ... Handle channel data.
  }
})();

socket.transmitPublish('foo', 'This is some data');

await socket.invokePublish('foo', 'This is some more data');

agServer.exchange.transmitPublish('foo', 'This is some data');

await agServer.exchange.invokePublish('foo', 'This is some more data');

expressApp.get('/login', async (req, res) => {
  const myTokenData = {
    username: 'bob',
    language: 'English',
    company: 'Google',
    groups: ['engineering', 'science', 'mathematics']
  };

  let signedTokenString = await agServer.auth.signToken(myTokenData, agServer.signatureKey);

  res.status(200).json({
    token: signedTokenString
  });
});

(async () => {
      for await (let request of socket.procedure('login')) {
        try {
          console.log("forawait -> request.data", request.data)
          //chgeck use done
  
          
        
          socket.setAuthToken({username: request.data.username});
          request.end();
          return;
        } catch(error) {
          console.log("forawait -> error", error)
          let loginError = new Error(`Could not find a ${request.data.username} user`);
          console.log("forawait -> loginError", loginError)
        loginError.name = 'LoginError';
        request.error(loginError);
  
        return;
        }        
      }
    })();

(async () => {
       
       try {
         // Invoke a custom 'login' procedure (RPC) on our server socket
         // then wait for the socket to be authenticated.
         const [, authResult] = await Promise.all([
           socket.invoke("login", credentials),
           socket.listener("authenticate").once(),
         ]);
       console.log("authResult", JSON.stringify(authResult))
     } catch (error) {
       console.log("error", error)
       // showLoginError(err);
       return;
     }
     })();

agServer.setMiddleware(agServer.MIDDLEWARE_INBOUND, async (middlewareStream) => {
  for await (let action of middlewareStream) {
    console.log("forawait -> action.type", action.type)
    if (action.type === action.TRANSMIT) {
      if (!action.data) {
        let error = new Error(
          'Transmit action must have a data object'
        );
        error.name = 'InvalidActionError';
        action.block(error);
        continue;
      }
    } else if (action.type === action.INVOKE) {
      if (!action.data) {
        let error = new Error(
          'Invoke action must have a data object'
          );
          error.name = 'InvalidActionError';
          action.block(error);
          continue;
        }
        // token 的物件
        console.log("forawait -> action.data", action.data)
    }
    action.allow();
  }
});

import React from 'react';
import {
  StyleSheet,
  View,
  Text,
  TouchableOpacity,
} from 'react-native';


class App extends React.Component { 
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  increment = () => {
    this.setState({ count: this.state.count + 1 })
  }

  render() {
    return (
      <View style={styles.container}>
        <TouchableOpacity
          style={[styles.wrapper, styles.border]}
          onPress={this.increment}
        >
          <Text style={styles.button}>
            {this.state.count}
          </Text>
        </TouchableOpacity>
      </View>
    );
  }

}
const styles = StyleSheet.create({
  container: {
    flex: 1, alignItems: "stretch"
  },
  wrapper: {
    flex: 1, alignItems: "center", justifyContent: "center"
  },
  border: {
    borderColor: "#eee", borderBottomWidth: 1
  },
  button: {
    fontSize: 50, color: "orange"
  }
});

export default App;

import React from 'react';
import {
  StyleSheet,
  View,
  Text,
  TouchableOpacity,
  requireNativeComponent,
} from 'react-native';

const CounterView = requireNativeComponent("CounterView");

class App extends React.Component { 
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  increment = () => {
    this.setState({ count: this.state.count + 1 })
  }

  render() {
    return (
      <View style={styles.container}>
        <TouchableOpacity
          style={[styles.wrapper, styles.border]}
          onPress={this.increment}
        >
          <Text style={styles.button}>
            {this.state.count}
          </Text>
        </TouchableOpacity>

        <CounterView style={ styles.wrapper } count={2} />
      </View>
    );
  }

}
const styles = StyleSheet.create({
  container: {
    flex: 1, alignItems: "stretch"
  },
  wrapper: {
    flex: 1, alignItems: "center", justifyContent: "center"
  },
  border: {
    borderColor: "#eee", borderBottomWidth: 1
  },
  button: {
    fontSize: 50, color: "orange"
  }
});

export default App;

/**
 * Sample React Native App
 * https://github.com/facebook/react-native
 *
 * @format
 * @flow
 */

import React from 'react';
import {
  StyleSheet,
  View,
  Text,
  UIManager,
  TouchableOpacity,
  requireNativeComponent,
} from 'react-native';

const CounterView = requireNativeComponent("CounterView");

class App extends React.Component { 
  constructor(props) {
    super(props);
    this.state = {
      count: 0
    };
  }

  increment = () => {
    this.setState({ count: this.state.count + 1 })
  }
  update = e => {
    this.setState({
      count: e.nativeEvent.count
    })
  }

  _onUpdate = event => {
    if (this.props.onUpdate) {
      this.props.onUpdate(event.nativeEvent);
    }
  };
  
  updateNative = () => {
    UIManager.dispatchViewManagerCommand(
      findNodeHandle(this.counterRef),                     // 1
      UIManager["CounterView"].Commands.updateFromManager, // 2
      [this.state.count]                                   // 3
    );
  }

  render() {
    return (
      <View style={styles.container}>
        <TouchableOpacity
          style={[styles.wrapper, styles.border]}
          onPress={this.increment}
        >
          <Text style={styles.button}>
            {this.state.count}
          </Text>
        </TouchableOpacity>

        <CounterView
          style={ styles.wrapper }
          count={this.state.count}
          onUpdate={this._onUpdate}
          ref={ref => this.ref = ref}
        />
      </View>
    );
  }

}
const styles = StyleSheet.create({
  container: {
    flex: 1, alignItems: "stretch"
  },
  wrapper: {
    flex: 1, alignItems: "center", justifyContent: "center"
  },
  border: {
    borderColor: "#eee", borderBottomWidth: 1
  },
  button: {
    fontSize: 50, color: "orange"
  }
});

export default App;

// 可以在設定中 disable service name prefix

{
  $noServiceNamePrefix: true
}

{
    name: "posts",
    version: 2,
    actions: {
        find() {...}
    }
}

const broker = new ServiceBroker({
    hotReload: true
});

broker.loadService("./services/test.service.js");

$ moleculer-runner --hot ./services/test.service.js

const http = require("http");

module.exports = {
    name: "www",

    settings: {
        port: 3000
    },

    created() {
        // Create HTTP server
        this.server = http.createServer(this.httpHandler);
    },

    started() {
        // Listening...
        this.server.listen(this.settings.port);
    },

    stopped() {
        // Stop server
        this.server.close();
    },

    methods() {
        // HTTP handler
        httpHandler(req, res) {
            res.end("Hello Moleculer!");
        }
    }
}

const Service = require("moleculer").Service;

class GreeterService extends Service {

    constructor(broker) {
        super(broker);

        this.parseServiceSchema({
            name: "greeter",
            version: "v2",
            meta: {
                scalable: true
            },
            dependencies: [
                "auth",
                "users"
            ],

            settings: {
                upperCase: true
            },
            actions: {
                hello: this.hello,
                welcome: {
                    cache: {
                        keys: ["name"]
                    },
                    params: {
                        name: "string"
                    },
                    handler: this.welcome
                }
            },
            events: {
                "user.created": this.userCreated
            },
            created: this.serviceCreated,
            started: this.serviceStarted,
            stopped: this.serviceStopped,
        });
    }

    // Action handler
    hello() {
        return "Hello Moleculer";
    }

    // Action handler
    welcome(ctx) {
        return this.sayWelcome(ctx.params.name);
    }

    // Private method
    sayWelcome(name) {
        this.logger.info("Say hello to", name);
        return `Welcome, ${this.settings.upperCase ? name.toUpperCase() : name}`;
    }

    // Event handler
    userCreated(user) {
        this.broker.call("mail.send", { user });
    }

    serviceCreated() {
        this.logger.info("ES6 Service created.");
    }

    serviceStarted() {
        this.logger.info("ES6 Service started.");
    }

    serviceStopped() {
        this.logger.info("ES6 Service stopped.");
    }
}

module.exports = GreeterService;