nicdex/node-eventstore-client
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor samples

Browse Source
This commit is contained in:
Paul 2017-04-20 19:32:53 -07:00
parent 83cfa8fe1c
commit 4130ab646c
4 changed files with 170 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
samples/simple.js
View File

@ -1,39 +1,46 @@
var client = require('../src/client'); const client = require("eventstore-node")
var uuid = require('uuid'); const uuid = require("uuid")
var settings = { const settings = {
verboseLogging: true, verboseLogging: true,
log: new client.FileLogger('./simple-verbose.log') log: new client.FileLogger("./simple-verbose.log")
}; }
var gossipSeeds = [ const gossipSeeds = [
new client.GossipSeed({host: '192.168.33.10', port: 2113}), new client.GossipSeed({host: "192.168.33.10", port: 2113}),
new client.GossipSeed({host: '192.168.33.11', port: 2113}), new client.GossipSeed({host: "192.168.33.11", port: 2113}),
new client.GossipSeed({host: '192.168.33.12', port: 2113}) new client.GossipSeed({host: "192.168.33.12", port: 2113})
]; ]
var conn = client.createConnection(settings, gossipSeeds); const connection = client.createConnection(settings, gossipSeeds)
conn.connect()
.catch(function (err) { connection.connect().catch(err => console.log(err))
console.log(err);
//process.exit(-1); connection.on("connected", endPoint => {
}); console.log(`connected to endPoint ${endPoint}`)
conn.on('connected', function (endPoint) {
console.log('connected to endPoint', endPoint); setInterval(() => {
//Start some work connection.appendToStream(
setInterval(function () { `test-${uuid.v4()}`,
conn.appendToStream('test-' + uuid.v4(), client.expectedVersion.noStream, [ client.expectedVersion.noStream,
client.createJsonEventData(uuid.v4(), {abc: 123}, null, 'MyEvent') [
]).then(function (writeResult) { client.createJsonEventData(
console.log(writeResult); uuid.v4(),
}); { abc: 123 },
}, 1000); null,
}); "MyEvent"
conn.on('error', function (err) { )
console.log('Error occurred on connection:', err); ]
}); ).then(writeResult => console.log(writeResult))
conn.on('closed', function (reason) { }, 1000)
console.log('Connection closed, reason:', reason); })
//process.exit(-1);
}); connection.on("error", error =>
process.stdin.setRawMode(true); console.log(`Error occurred on connection: ${error}`)
process.stdin.resume(); )
process.stdin.on('data', process.exit.bind(process, 0));
connection.on("closed", reason =>
console.log(`Connection closed, reason: ${reason}`)
)
process.stdin.setRawMode(true)
process.stdin.resume()
process.stdin.on("data", process.exit.bind(process, 0))

81
samples/store-event.js
View File

@ -1,40 +1,51 @@
var esClient = require('../src/client'); // When running in 'eventstore-node/samples' folder. const client = require("eventstore-node")
// var esClient = require('eventstore-node'); // Otherwise const uuid = require("uuid")
var uuid = require('uuid');
var esConnection = esClient.createConnection({}, {"host": "localhost", "port": 1113}); const settings = {}
esConnection.connect(); const endpoint = { host: "localhost", port: 1113 }
esConnection.once('connected', function (tcpEndPoint) { const connection = client.createConnection(settings, endpoint)
console.log('Connected to eventstore at ' + tcpEndPoint.host + ":" + tcpEndPoint.port);
var userId = uuid.v4(); connection.connect().catch(err => console.log(err))
// This event could happen as a result of (e.g.) a 'CreateUser(id, username, password)' command.
var userCreatedEvent = { connection.once("connected", tcpEndPoint => {
const userId = uuid.v4()
const userCreatedEvent = {
id: userId, id: userId,
username: "user" + uuid.v4().substring(0,6), // Hard-to-spell exotic username. username: `user${uuid.v4().substring(0,6)}`,
password: Math.random().toString() // Hard-to-guess password. password: Math.random().toString()
}; }
var eventId = uuid.v4();
var event = esClient.createJsonEventData(eventId, userCreatedEvent, null, "UserCreated"); const event = client.createJsonEventData(
// Every user has her/his own stream of events: uuid.v4(),
var streamName = "user-" + userId; userCreatedEvent,
console.log("Storing event. Look for it at http://localhost:2113/web/index.html#/streams/user-" + userId); null,
esConnection.appendToStream(streamName, esClient.expectedVersion.any, event) "UserCreated"
.then(function(result) { )
console.log("Event stored.");
process.exit(0); // Every user has their own stream of events:
const streamName = `user-${userId}`
console.log(`Connected to eventstore at ${tcpEndPoint.host}:${tcpEndPoint.port}`)
console.log(`Storing event. Look for it at http://localhost:2113/web/index.html#/streams/user-${userId}`)
connection.appendToStream(streamName, client.expectedVersion.any, event)
.then(result => {
console.log("Event stored.")
process.exit(0)
})
.catch(error => {
console.log(error)
process.exit(-1)
})
}) })
.catch(function(err) {
console.log(err);
process.exit(-1);
});
});
esConnection.on('error', function (err) { connection.on("error", error => {
console.log('Error occurred on connection:', err); console.log(`Error occurred on connection: ${error}`)
process.exit(-1); process.exit(-1)
}); })
esConnection.on('closed', function (reason) { connection.on("closed", reason => {
console.log('Connection closed, reason:', reason); console.log(`Connection closed, reason: ${reason}`)
process.exit(-1); process.exit(-1)
}); })

79
samples/subscribe-all-events.js
View File

@ -1,48 +1,49 @@
// Subscribe to all new events on the $all stream. Filter out any which aren't about "user" aggregates. // Subscribe to all new events on the $all stream. Filter out any which aren"t about "user" aggregates.
const client = require("eventstore-node")
var esClient = require('../src/client'); // When running in 'eventstore-node/samples' folder. const resolveLinkTos = false
// var esClient = require('eventstore-node'); // Otherwise
const credentialsForAllEventsStream = new esClient.UserCredentials("admin", "changeit"); const belongsToAUserAggregate = event =>
const resolveLinkTos = false; event.originalEvent.eventStreamId.startsWith("user-")
var esConnection = esClient.createConnection({}, {"host": "localhost", "port": 1113}); const eventAppeared = (subscription, event) => {
esConnection.connect();
esConnection.once('connected', function (tcpEndPoint) {
console.log('Connected to eventstore at ' + tcpEndPoint.host + ":" + tcpEndPoint.port);
esConnection.subscribeToAll(resolveLinkTos, eventAppeared, subscriptionDropped, credentialsForAllEventsStream)
.then(function(subscription) {
console.log("subscription.isSubscribedToAll: " + subscription.isSubscribedToAll);
console.log("(To generate a test event, try running 'node store-event.js' in a separate console.)")
});
});
function belongsToAUserAggregate(event) {
return event.originalEvent.eventStreamId.startsWith("user-")
}
function eventAppeared(subscription, event) {
// Ignore all events which aren't about users:
if (belongsToAUserAggregate(event)) { if (belongsToAUserAggregate(event)) {
var aggregateId = event.originalEvent.eventStreamId; const aggregateId = event.originalEvent.eventStreamId
var eventId = event.originalEvent.eventId; const eventId = event.originalEvent.eventId
var eventType = event.originalEvent.eventType; const eventType = event.originalEvent.eventType
console.log(aggregateId, eventType, eventId); console.log(aggregateId, eventType, eventId)
console.log(event.originalEvent.data.toString() + "\n"); console.log(event.originalEvent.data.toString())
} }
} }
function subscriptionDropped(subscription, reason, error) { const subscriptionDropped = (subscription, reason, error) =>
if (error) { console.log(error ? error : "Subscription dropped.")
console.log(error);
}
console.log('Subscription dropped.');
}
esConnection.on('error', function (err) { const credentials = new client.UserCredentials("admin", "changeit")
console.log('Error occurred on connection:', err);
});
esConnection.on('closed', function (reason) { const settings = {}
console.log('Connection closed, reason:', reason); const endpoint = { host: "localhost", port: 1113 }
}); const connection = client.createConnection(settings, endpoint)
connection.connect().catch(err => console.log(err))
connection.once("connected", tcpEndPoint => {
console.log(`Connected to eventstore at ${tcpEndPoint.host}:${tcpEndPoint.port}`)
connection.subscribeToAll(
resolveLinkTos,
eventAppeared,
subscriptionDropped,
credentials
).then(subscription => {
console.log(`subscription.isSubscribedToAll: ${subscription.isSubscribedToAll}`),
console.log("(To generate a test event, try running 'node store-event.js' in a separate console.)")
})
})
connection.on("error", error =>
console.log(`Error occurred on connection: ${error}`)
)
connection.on("closed", reason =>
console.log(`Connection closed, reason: ${reason}`)
)

80
samples/subscribe-catchup-all-events.js
View File

@ -1,51 +1,47 @@
// Subscribe to all events on the $all stream. Catch up from the beginning, then listen for any new events as they occur. // Subscribe to all events on the $all stream. Catch up from the beginning, then listen for any new events as they occur.
// This can be used (e.g.) for subscribers which populate read models. // This could be used for subscribers which populate read models.
const client = require("eventstore-node")
var esClient = require('../src/client'); // When running in 'eventstore-node/samples' folder. const eventAppeared => (stream, event) =>
// var esClient = require('eventstore-node'); // Otherwise console.log(
event.originalEvent.eventStreamId,
event.originalEvent.eventId,
event.originalEvent.eventType
)
const credentialsForAllEventsStream = new esClient.UserCredentials("admin", "changeit"); const liveProcessingStarted = () => {
console.log("Caught up with previously stored events. Listening for new events.")
var esConnection = esClient.createConnection({}, {"host": "localhost", "port": 1113});
esConnection.connect();
esConnection.once('connected', function (tcpEndPoint) {
console.log('Connected to eventstore at ' + tcpEndPoint.host + ":" + tcpEndPoint.port);
var subscription = esConnection.subscribeToAllFrom(null, true, eventAppeared, liveProcessingStarted, subscriptionDropped, credentialsForAllEventsStream);
console.log("subscription.isSubscribedToAll: " + subscription.isSubscribedToAll);
});
function eventAppeared(subscription, event) {
// This is where to filter out events which the subscriber isn't interested in.
// For an example, see 'subscribe-all-events.js'.
console.log(event.originalEvent.eventStreamId);
}
function subscriptionDropped(subscription, reason, error) {
if (error) {
console.log(error);
}
console.log('Subscription dropped.');
}
function liveProcessingStarted() {
console.log("Caught up with previously stored events. Listening for new events.");
console.log("(To generate a test event, try running 'node store-event.js' in a separate console.)") console.log("(To generate a test event, try running 'node store-event.js' in a separate console.)")
} }
function eventAppeared(stream, event) { const subscriptionDropped = (subscription, reason, error) =>
console.log(event.originalEvent.eventStreamId, event.originalEvent.eventId, event.originalEvent.eventType); console.log(error ? error : "Subscription dropped.")
// Data:
// console.log(event.originalEvent.data.toString());
// Position in the event stream. Can be persisted and used to catch up with missed events when re-starting subscribers instead of re-reading const credentials = new client.UserCredentials("admin", "changeit")
// all events from the beginning.
// console.log(event.originalPosition);
}
esConnection.on('error', function (err) { const settings = {}
console.log('Error occurred on connection:', err); const endpoint = { host: "localhost", port: 1113 }
}); const connection = client.createConnection(settings, endpoint)
esConnection.on('closed', function (reason) { connection.connect().catch(err => console.log(err))
console.log('Connection closed, reason:', reason);
}); connection.once("connected", tcpEndPoint => {
const subscription = connection.subscribeToAllFrom(
null,
true,
eventAppeared,
liveProcessingStarted,
subscriptionDropped,
credentials
)
console.log(`Connected to eventstore at ${tcpEndPoint.host}:${tcpEndPoint.port}`)
console.log(`subscription.isSubscribedToAll: ${subscription.isSubscribedToAll}`)
})
connection.on("error", err =>
console.log(`Error occurred on connection: ${err}`)
)
connection.on("closed", reason =>
console.log(`Connection closed, reason: ${reason}`)
)