Streams

In software engineering, a fluent interface is an object-oriented API whose design relies extensively on method chaining. Its goal is to increase code legibility by creating a domain-specific language (DSL). (↪wiki)

In @fluentfixture, factories are small and valuable units, but they are very incapable of building complex and conditional data. Streams are factory wrappers (stream is a kind of factory) that provide a fluent interface. All methods of streams create other streams that wrap themselves. Like any factory, streams are also immutable and reusable types.

Stream instances cannot be initialized directly. Instead of this, generator functions can be used.

Decomposition Of A Stream

In the following example, a stream is built by compositions of many components.

import { int } from '@fluentfixture/core';

const stream = int(1, 100)
  .add(0.5)
  .array(10)
  .sort((a,b) => a - b)
  .join('/')
  .format('numbers = ${}')
  .upperCase();

console.log(stream.single());
// Prints like;
// NUMBERS = 4.5/5.5/40.5/41.5/48.5/52.5/56.5/68.5/72.5/83.5

Let's decompose the stream above to understand the stream and factory concept.

Code	Output	Sub-Component	Job
int(1, 100)	NumberStream	IntegerFactory	generates an integer
.add(0.5)	NumberStream	FunctionDecorator	adds 0.5 to the previous output
.array(10)	ArrayStream	Iterator	Iterates to decorated factory
.sort(...)	ArrayStream	FunctionDecorator	sorts the previous output
.join(...)	StringStream	FunctionDecorator	merge the previos output
.format(...)	StringStream	FormatDecorator	formats the previous output
.upperCase()	StringStream	FunctionDecorator	converts to upper case the previous outout

Class Hierarchy

To addition that, the relationship between factories and streams can be illustrated as the following figure.