fakeStoreJs 🚧

fakeStoreJs make mocking easy, quickly create a CRUD access to any object

• Create multiple store in less than a heartbeat ! ♥️
• Come with a unique id attribution ! 💥
• Extends CRUD method using resolvers ! 🔓
• Persistent data ! 🆕
• Easy to use ! 🔥

If something doesn’t work, please file an issue 🐛.

QuickStart 🚀

Install

$ npm install fakestorejs or yarn install fakestorejs

Use it Now !

Start importing createStore from fakeStoreJs.

const createStore = require('fakestorejs');

Create a store from any object.

const store = createStore({
  book: {
    data: [
      { title: 'Speaking JavaScript', author: 'Dr. Axel Raushmayer' },
      { title: 'Effective JavaScript', author: 'David Herman' },
      { title: 'Eloquent Javascript', author: 'Marijin Haverbeke' },
      { title: 'You-Dont-Know-JS', author: 'Kyle Simpson' }
    ]
  }
});

🎉 Start using it 🎉

store.book.get();
// { sucess: true, data: [ { uid: "000000" author: "Speaking JavaScript", title: "Dr. Axel Raushmayer" }, ...] }

Usage

Requirements

fakeStoreJs need an object with at least on key. Each key represent a collection name (or table name) and they must provide an array of data or a schema, look at the example below.

const store = createStore({
  dragon: {
    data: [], // can be empty or fill with any object
    schema: function Dragon() {}, // deprecated use of anonymous function
    options: { useSchema: true } // Must be specified or it will create a schema from the data given see next example (schemaless)
  }
});

Or

const store = createStore({
  dragon: {
    data: [{ name: 'Frizzly', type: 'Ice' }] // Must have at least one object inside the data field
  }
});

Let's now have a deeper look at what are schema.

Schema

A schema is the 'constructor' used by fakestorejs to create new object.

Example : You want to create a store of users, each user should have a username build from its lastname and firstname, you need to specified it :

const store = createStore({
  user: {
    data: [],
    schema: function User({ firstname, lastname }) {
      this.firstname = firstname;
      this.lastname = lastname;
      this.username = `${firstname[0]}.${${lastname}}` // Usualy schema are used to create 'calculated' properties otherwise use fakeStoreJs schemaless strategy
    },
    options: {
      useSchema: true
    }
  }
});

Schemaless strategy

Most of the time when mocking data you don't need complexity properties like in the schema model, this is the schemaless fakeStoreJs strategy.

const store = createStore({
  user: {
    data: [{ firstname: 'David', lastname: 'Herman' }] // fakeStoreJs will automatically create a schema that take every key from your first object inside your data array
  }
});

Methods

fakeStoreJs comes with embedded crud like method : However you can override them and or create new one using resolvers !

Method	Parameters	sucess	error
post()	obj: Object	{ sucess: Boolean, data: Object }	{ sucess: Boolean, error: String }
get()	None	{ sucess: Boolean, data: Object }	{ sucess: Boolean, error: String }
put()	uid: String, obj: Object	{ sucess: Boolean, data: Object }	{ sucess: Boolean, error: String }
delete()	uid: String	{ sucess: Boolean}	{ sucess: Boolean, error: String }

FakeStoreJs will add a unique identifier(uid) for each item.

Resolvers

Resolvers allow custom methods by adding a key inside your object call resolvers :

const store = createStore({
  book: {
    data: [
      { title: 'Speaking JavaScript', author: 'Dr. Axel Raushmayer' },
      { title: 'Effective JavaScript', author: 'David Herman' },
      { title: 'Eloquent Javascript', author: 'Marijin Haverbeke' },
      { title: 'You-Dont-Know-JS', author: 'Kyle Simpson' }
    ],
    resolvers: {
      // Add your own methods !!
      getById: function(uid) {
        // do not use arrow function
        const item = this.collection.find(item => item.uid === uid);
        return item
          ? { sucess: true, data: item }
          : { sucess: false, error: 'couldnt match the uid' };
      },
      multiplePost: function(arrayOfObj) {
        let error = false;
        const collectionPreviousState = this.collection;
 
        for (let [i, obj] of arrayOfObj.entries()) {
          try {
            obj = this.Book(obj); // use of the schema context, 'collection': book with 'schema': Book
            this.collection = [...this.collection, obj];
          } catch (e) {
            error = { sucess: false, error: e };
            break;
          }
          arrayOfObj[i] = obj;
        }
 
        if (error) {
          this.collection = collectionPreviousState;
          return error;
        } else return { sucess: true, data: arrayOfObj };
      }
    }
  }
});

fakeStoreJs bind the resolvers with a neat context : { collection: Array, schema: Function } where :

• collection is the table from your store(database).
• schema is your schema from the createStore().

Nb: schema will always be your collection name capitalized.

example: book schema will be Book

Options

It is possible to add options to fakeStoreJs using the key : options :

const store = createStore({
  book: {
    data: [
      { title: 'Speaking JavaScript', author: 'Dr. Axel Raushmayer' },
      { title: 'Effective JavaScript', author: 'David Herman' },
      { title: 'Eloquent Javascript', author: 'Marijin Haverbeke' },
      { title: 'You-Dont-Know-JS', author: 'Kyle Simpson' }
    ],
    schema: function Book({ author, title }) {
      this.author = author;
      this.title = title;
    },
    options: {
      idLabel: 'id',
      useSchema: true
    }
  }
});

Method	Type	informations	Default
idLabel	String	Use as 'key name' for the generate identifier	'uid'
useSchema	Boolean	Switch beetween embedded schema constructor or your own schema	false
isPersistent	Boolean	Keep the data even after a restart	false
isDataDeletable	Boolean	Delete the initial data from the data field	false

Contributing

This project welcome any new contribution.