Nurturing Palpable Magnificence

    @rxdi/core
    TypeScript icon, indicating that this package has built-in type declarations

    0.7.153 • Public • Published

    Powerful Dependency Injection inside Browser and Node using Typescript and RXJS 6


    The idea behind @rxdi is to create independent, dependency injection that can be used everywhere, Node and Browser with purpose also to share the same code without chainging nothing! First steps where with platform called @gapi you can check repository @gapi/core. Then because of the needs of the platform i decided to develop this Reactive Dependency Injection container helping me build progressive applications. Hope you like my journey! Any help and suggestions are appreciated! Main repository @rxdi/core


    Example starter projects:

    Client Side

    Client Side Advanced

    Server Side

    More examples for @rxdi infrastructure you can check inside @gapi namespace.

    @Beta Decentralized node_modules using ipfs network with rxdi infrastructure

    Install @rxdi/core global so we will have rxdi command available npm i -g @rxdi/core

    Install single decentralized ipfs module rxdi install QmWtJLqyokMZE37DgncpY5HhFvtFQieBzMPDQ318aJeTw6

    More details you can find here ipfs-package-example

    Example module https://ipfs.io/ipfs/QmWtJLqyokMZE37DgncpY5HhFvtFQieBzMPDQ318aJeTw6

    @rxdi/core can be found also inside decentralized space here

    @rxdi/core can be installed with '@rxdi/core' total inception :D rxdi i QmP9n7m1UWkFn2hqt7mnfQYnBtxmFyyvKZHN7hgngQb1gM

    No more package downtime!

    Installation and basic examples:

    To install this library, run:
    npm install @rxdi/core

    Simplest app

    main.ts

    import { Bootstrap } from '@rxdi/core';
    import { AppModule } from './app/app.module';
    
    Bootstrap(AppModule, {
     init: false, // if init is false you can set specifically which parts of the system should initialize their constructors
     initOptions: {
      services: true,
      components: true,
      effects: true,
      controllers: true,
      plugins: true,
      pluginsAfter: true,
      pluginsBefore: true,
     },
     logger: {
      logging: true,
      date: true,
      hashes: true,
      exitHandler: true,
     },
    }).subscribe(
     () => console.log('App Started!'),
     (err) => console.error(err),
    );

    app.module.ts

    import { Module } from '@rxdi/core';
    import { UserModule } from './user/user.module';
    
    @Module({
     imports: [UserModule],
    })
    export class AppModule {}

    user.module.ts

    import { Module } from '@rxdi/core';
    import { UserService } from './services';
    import { Observable } from 'rxjs';
    
    @Module({
     services: [
      UserService,
      {
       provide: 'createUniqueHash',
      },
      {
       provide: 'testFactoryAsync',
       lazy: true,
       useFactory: async () => {
        return new Promise((resolve) => {
         setTimeout(() => resolve('dad2a'), 0);
        });
       },
      },
      {
       provide: 'testFactorySync',
       useFactory: () => {
        return 'dada';
       },
      },
      {
       provide: 'testValue2',
       useValue: 'dadada',
      },
      {
       provide: 'testChainableFactoryFunction',
       // lazy: true, if you don't provide lazy parameter your factory will remain Observable so you can chain it inside constructor
       useFactory: () => new Observable((o) => o.next(15)),
      },
     ],
    })
    export class UserModule {}

    user.service.ts

    import { Service, Inject } from '@rxdi/core';
    import { Observable } from 'rxjs';
    import { map } from 'rxjs/operators';
    
    @Service()
    export class UserService {
     constructor(
      @Inject('createUniqueHash') private ipfsDownloadedFactory: { testKey: () => string },
      @Inject('testFactoryAsync') private testFactoryAsync: { testKey: () => string },
      @Inject('testChainableFactoryFunction') private chainableFactory: Observable<number>,
     ) {
      console.log('UserService', this.ipfsDownloadedFactory.testKey(), this.testFactoryAsync);
      this.chainableFactory
       .pipe(map((res) => res))
       .subscribe((value) => console.log('Value chaining factory ', value));
     }
    }

    Result

    1529604446114 Bootstrap -> @Module('AppModule')(adb785e839fa19736cea0920cd39b783): loading...
    1529604446116 Bootstrap -> @Module('UserModule')(9ed4f039657f52019d2d9adb0f9df09f): loading...
    1529604446118 Bootstrap -> @Module('UserModule')(9ed4f039657f52019d2d9adb0f9df09f): finished!
    1529604446118 Bootstrap -> @Module('AppModule')(adb785e839fa19736cea0920cd39b783): finished!
    1529604446119 Bootstrap -> @Service('createUniqueHash'): loading...
    1529604446121 Bootstrap -> @Service('createUniqueHash'): will be downloaded inside ./node_modules/@helpers/createUniqueHash.js folder and loaded from there
    1529604446121 Bootstrap -> @Service('createUniqueHash'): https://ipfs.infura.io/ipfs/QmdQtC3drfQ6M6GFpDdrhYRKoky8BycKzWbTkc4NEzGLug downloading...
    1529604446137 Bootstrap -> @Service('testFactoryAsync'): loading...
    1529604446146 Bootstrap -> @Service('testFactoryAsync'): loading finished! 21:07:26
    1529604446795 Done!
    1529604446797 Bootstrap: @Service('createUniqueHash.js'): Saved inside /home/rampage/Desktop/concept-starter/node_modules/@helpers
    1529604446808 Bootstrap -> @Service('createUniqueHash'): loading finished! 21:07:26
    1529604446810 Done!
    1529604446811 Bootstrap: @Service('createUniqueHash.js'): Saved inside /home/rampage/Desktop/concept-starter/node_modules/@helpers
    1529604446812 Bootstrap -> press start!
    1529604446813 Start -> @Module('UserModule')(9ed4f039657f52019d2d9adb0f9df09f): @Service('UserService')(ea785b316b77dbfe5cb361a7cdcbcb31) initialized!
    UserService TestKey dad2a
    Value chaining factory  15
    1529604446813 Start -> @Module('UserModule')(9ed4f039657f52019d2d9adb0f9df09f): loaded!
    1529604446813 Start -> @Module('AppModule')(adb785e839fa19736cea0920cd39b783): loaded!
    Started!
    AppStopped

    ForRoot configuration for modules

    import { Module, ModuleWithServices, InjectionToken } from '@rxdi/core';
    
    @Service()
    export class MODULE_DI_CONFIG {
     text: string = 'Hello world';
    }
    
    export const MY_MODULE_CONFIG = new InjectionToken<MODULE_DI_CONFIG>('my-module-config');
    
    @Module({
     imports: [],
    })
    export class YourModule {
     public static forRoot(config?: any): ModuleWithServices {
      return {
       module: YourModule,
       services: [
        { provide: MY_MODULE_CONFIG, useValue: { text: 'Hello world' } },
        { provide: MY_MODULE_CONFIG, useClass: MODULE_DI_CONFIG },
        {
         provide: MY_MODULE_CONFIG,
         useFactory: () => {
          return { text: 'Hello world' };
         },
        },
       ],
       components: [],
       frameworkImports: [],
      };
     }
    }

    Parcel

    Inside @gapi/cli package there is a command called gapi start --local --parcel this command will run @gapi or @rxdi application with parcel there is a also command called gapi build which will take src/main.ts and will bundle it the same way like parcel build src/main.ts --target node

    To install @gapi/cli type:

    npm i -g @gapi/cli

    Start with @gapi/cli

    gapi start --local --parcel

    Build with @gapi/cli

    gapi build

    Or you can install Parcel globally and use instead of @gapi/cli

    Install Parcel:

    npm install -g parcel-bundler

    Build single bundle from first bootstrapped file in this case main.ts

    parcel build src/main.ts --target node

    This command will generate single file from this application inside dist/main.js with mappings dist/main.map

    Starting bundled application

    node ./dist/main.js

    Important!

    This will not bundle your node modules only rxdi application.

    If you want to start app with ts-node for example you need to set inside tsconfig.json -> compilerOptions: {}

    {
     "compilerOptions": {
      "emitDecoratorMetadata": true,
      "experimentalDecorators": true
     }
    }

    Possible pattern with @rxdi/core

    import { setup } from '@rxdi/core';
    import { switchMap } from 'rxjs/operators';
    import { combineLatest } from 'rxjs';
    
    setup({
     services: [
      {
       provide: 'gosho',
       lazy: true,
       useFactory: async () => 'yey',
      },
     ],
    })
     .pipe(
      switchMap((ctx) =>
       combineLatest(
        setup({
         services: [
          {
           provide: 'pesho',
           useFactory: () => (ctx as any).get('gosho'),
          },
         ],
        }),
        setup({
         services: [],
        }),
        setup({
         services: [],
        }),
        setup({
         services: [],
        }),
       ),
      ),
     )
     .subscribe((ctx) => {
      console.log((ctx as any).get('pesho'));
     });

    Keywords

    none

    Install

    npm i @rxdi/core

    DownloadsWeekly Downloads

    1,124

    Version

    0.7.153

    License

    MIT

    Unpacked Size

    204 kB

    Total Files

    192

    Last publish

    Collaborators

    • gapi
    • rxdi