Needlessly Postulating Minds

    lmao

    2.3.0 • Public • Published

    lmao

    lmao (load modules in an object) helps you load modules into an object with a specific structure.

    Imagine you have a project with the following structure:

    .__ client/
    |  |__ netsuite/
    |  |  |__ modules/
    |  |  |   |__ stores.js
    |  |  |__ index.js
    |  |__ sap/
    |  |  |__ modules/
    |  |  |   |__ products.js
    |  |  |   |__ recipes.js
    |  |  |__ index.js
    |  |__ rest.js
    |  |__ soap.js
    |__ public/
    |  |__ json
    |     |__ disclaimer.json
    |     |__ privacy.json
    |__ service/
    |  |__ product.js
    |  |__ recipe.js
    |  |__ store.js
    |__ transformation/
    |  |__ product.js
    |  |__ recipe.js
    |  |__ store.js
    |__util.js
    

    And now you want to:

    • Import all these modules into a single object -we will call it "API" from now on-
    • Have total control over the structure of the resulting API object
    • Not worry to manually add, for instance, a new file you created inside service/
    • Not worry about circular dependencies while loading all these modules

    With lmao you can load all those modules directly into an object with a specific structure. lmao only needs what we call a descriptor, which defines:

    • The structure of the API object (using dot notation à la keypather)
    • What files will be loaded (using glob path notation)

    Example:

    var lmao = require('lmao');
     
    var api = module.exports = {
        version: '0.1.0'
    };
     
    lmao(api, {
        _root: ['example/util.js', 'example/metrics.js' ], // Root level, multiple paths
        client: 'example/client/*.js',
        'client.sap': {
            _root: 'example/client/sap/index.js',
            _children: 'example/client/sap/modules/*.js'
        },
        'client.netsuite': {
            _root: 'example/client/netsuite/index.js',
            _children: 'example/client/netsuite/modules/*.js'
        },
        static: 'example/public/**/*.json',
        transformation: 'example/transformation/*.js',
        service: 'example/service/*.js'
    });
     
    //
    // console.log output
    //
     version: '0.1.0',
      util: { log: [Function: bound ] },
      client:
       { rest: [Function: rest],
         soap: [Function: soap],
         sap:
          { request: [Function],
            options: { remoteUri: 'http://my-sap.com/my-api' },
            products: { search: [Function], details: [Function] },
            recipes: { search: [Function], details: [Function] } },
         netsuite:
          { request: [Function],
            options: { remoteUri: 'http://my-netsuite.com/my-api' },
            stores: { search: [Function], details: [Function] } } },
      static:
       { disclaimer:
          { title: 'Disclaimer',
            description: 'Lorem ipsum dolor sit amet' },
         privacy: { title: 'Privacy', description: 'Lorem ipsum dolor sit amet' } },
      transformation:
       { product:
          { transformProductList: [Function],
            transformProductDetails: [Function] },
         recipe:
          { transformRecipeList: [Function],
            transformRecipeDetails: [Function] },
         store:
          { transformStoreList: [Function],
            transformStoreDetails: [Function] } },
      service:
       { product: { search: [Function], details: [Function] },
         recipe: { search: [Function], details: [Function] },
         store: { search: [Function], details: [Function] } } }

    Now you can start using your API!

    api.service.product.search(...);
    api.service.recipe.transformRecipList(...);
    api.client.rest(...);
    

    Installation

    You can install lmao with npm:

    npm install lmao
    

    Usage

    You can see a full-fledged example, which includes circular dependencies, in the example folder.

    lmao([target,] descriptor)

    Loads modules into an object as defined by descriptor, optionally merging them into the existing target object.

    Arguments

    • target - Optional object where the modules will be loaded into. Existing properties will be overwritten.
    • descriptor - An object that describes what modules will be loaded, and in what path they'll be placed.
      • The keys of the descriptor are object paths in dot notation, like those of keypather.
      • The values of the descriptor are glob paths
        • You can provide multiple paths with an array of strings
        • If you want to have more control over the destination, you can wrap the values in an object with properties _root and _children. Root modules will not use the file name as property name; children will.

    Example

    Builds an object loaded with modules in a specific structure.

    lmao(api, {
        _root: ['example/util.js', 'example/metrics.js' ], // Root level, multiple paths
        client: 'example/client/*.js',
        'client.sap': {
            _root: 'example/client/sap/index.js', // Root level modules (client.sap.*)
            _children: 'example/client/sap/modules/*.js' // Children modules (client.sap.<filename>.*)
        },
        'client.netsuite': {
            _root: 'example/client/netsuite/index.js',
            _children: 'example/client/netsuite/modules/*.js'
        },
        static: 'example/public/**/*.json',
        transformation: 'example/transformation/*.js',
        service: 'example/service/*.js'
    });

    Development

    • Linting: gulp lint
    • Testing and coverage: gulp test
    • Generate JSDoc files: gulp jsdoc

    License

    MIT

    Ayy?

    Lmao

    Install

    npm i lmao

    DownloadsWeekly Downloads

    40

    Version

    2.3.0

    License

    MIT

    Last publish

    Collaborators

    • dunkelheit