@rocketmakers/ioc 0.2.6 → 0.3.3

package/README.md

@@ -44,7 +44,7 @@ export function getExternalUserData(apiKey: string, id: number): IUser {
 ```
 `ioc/types.ts`
 ```TypeScript
-import { Curried1 } from '@rocketmakers/ioc';
+import { Curried1, Curried2 } from '@rocketmakers/ioc';
 
 // Application Types
 import type { AdminController } from '../controller/admin';
@@ -53,10 +53,13 @@ import type { getExternalUserData } from '../service/external-api';
 
 /** Define the types registered within the container */
 export type ControllerContainerTypes = {
+  id: number;
+  apiKey: string;
   adminService: AdminService;
   adminController: AdminController;
-  apiKey: string;
-  getExternalUserData: Curried1<typeof getExternalUserData>;
+  getExternalUserData: typeof getExternalUserData;
+  getExternalUserData1: Curried1<typeof getExternalUserData>;
+  getExternalUserData2: Curried2<typeof getExternalUserData>;
 };
 
 ```
@@ -67,40 +70,82 @@ export type ControllerContainerTypes = {
 
 `ioc/register.ts`
 ```TypeScript
-import { containerRegisterFunctionResolver, IContainer, register } from '@rocketmakers/ioc';
+import { IContainer, register } from '@rocketmakers/ioc';
 
 import { AdminController } from '../controller/admin';
 import { AdminService } from '../service/admin';
 import { getExternalUserData } from '../service/external-api';
 import { ControllerContainerTypes } from './types';
 
-export const functionResolver = containerRegisterFunctionResolver<ControllerContainerTypes>();
-
 export function makeContainer(): IContainer<ControllerContainerTypes> {
   // Register all the keys of the 'ControllerContainerTypes'
   return register<ControllerContainerTypes>({
-    adminController: b => b.class(AdminController).construct(['adminService']),
-    adminService: b => b.class(AdminService).construct([]),
+    id: b => b.constant(31313),
     apiKey: b => b.constant('xyz...'),
-    getExternalUserData: b => b.functionResolver(functionResolver.curry1(getExternalUserData, 'apiKey')),
+    adminService: b => b.class(AdminService, []),
+    adminController: b => b.class(AdminController, ['adminService']),
+    getExternalUserData: b => b.function(getExternalUserData),
+    getExternalUserData1: b => b.functionCurry(getExternalUserData, ['apiKey']),
+    getExternalUserData2: b => b.functionCurry(getExternalUserData, ['apiKey', 'id']),
+  });
+}
+
+```
+
+`ioc/register-with-prefix.ts`
+```TypeScript
+import { registerWithPrefix } from '@rocketmakers/ioc';
+
+import { AdminController } from '../controller/admin';
+import { AdminService } from '../service/admin';
+import { getExternalUserData } from '../service/external-api';
+import { ControllerContainerTypes } from './types';
+
+export function makeContainerPrefixed<TPrefix extends string>(prefix: TPrefix, id: number, apiKey: string) {
+  // Register all the keys of the 'ControllerContainerTypes'
+  return registerWithPrefix<TPrefix, ControllerContainerTypes>('none', prefix, {
+    id: b => b.constant(id),
+    apiKey: b => b.constant(apiKey),
+    adminService: b => b.class(AdminService, []),
+    adminController: b => b.class(AdminController, ['adminService']),
+    getExternalUserData: b => b.function(getExternalUserData),
+    getExternalUserData1: b => b.functionCurry(getExternalUserData, ['apiKey']),
+    getExternalUserData2: b => b.functionCurry(getExternalUserData, ['apiKey', 'id']),
   });
 }
 
+const v1 = makeContainerPrefixed('this-', 31313, 'xyz...');
+v1.get('this-id');
+v1.get('this-apiKey');
+v1.get('this-adminService');
+v1.get('this-adminController');
+v1.get('this-getExternalUserData');
+v1.get('this-getExternalUserData1');
+v1.get('this-getExternalUserData2');
+
+const v2 = makeContainerPrefixed('that-', 13131, 'abc...');
+v2.get('that-id');
+v2.get('that-apiKey');
+v2.get('that-adminService');
+v2.get('that-adminController');
+v2.get('that-getExternalUserData');
+v2.get('that-getExternalUserData1');
+v2.get('that-getExternalUserData2');
+
 ```
 
 ### Resolving with the container
 
 ```TypeScript
-import { makeContainer } from './ioc/register-new';
+import { makeContainer } from './ioc/register';
 
 export function boot() {
   // Register the container
   const container = makeContainer();
 
-  //  getExternalUserData has type "(id: number): IUser" as we curried out the apiKey param
-  const getExternalUserData = container.get('getExternalUserData');
-
-  const userData = getExternalUserData(23);
+  //  getExternalUserData1 has type "(id: number): IUser" as we curried out the apiKey param
+  const getExternalUserData1 = container.get('getExternalUserData1');
+  const userData = getExternalUserData1(23);
   return userData;
 }
 
@@ -123,17 +168,22 @@ import { AdminService } from '../service/admin';
 import { getExternalUserData } from '../service/external-api';
 import { ControllerContainerTypes } from './types';
 
-// Create legacy helper functions
+/** @deprecated LEGACY: Create register helper  */
 export const register = containerRegister<ControllerContainerTypes>();
+/** @deprecated LEGACY: Create function resolver  */
 export const functionResolver = containerRegisterFunctionResolver<ControllerContainerTypes>();
+/** @deprecated LEGACY: Create register container  */
 export const container = containerFactory<ControllerContainerTypes>();
 
 export function registerIoC(): void {
   // Register all the keys of the 'ControllerContainerTypes'
+  register.constant('id', 31313);
+  register.constant('apiKey', 'xyz...');
   register.class('adminService', AdminService).construct([]).inSingletonScope();
   register.class('adminController', AdminController).construct(['adminService']).inSingletonScope();
-  register.constant('apiKey', 'xyz...');
-  register.function('getExternalUserData', functionResolver.curry1(getExternalUserData, 'apiKey'));
+  register.function('getExternalUserData', getExternalUserData);
+  register.function('getExternalUserData1', functionResolver.curry1(getExternalUserData, 'apiKey'));
+  register.function('getExternalUserData2', functionResolver.curry2(getExternalUserData, 'apiKey', 'id'));
 }
 
 ```
@@ -141,16 +191,16 @@ export function registerIoC(): void {
 ### Resolving with the container
 
 ```TypeScript
-import { container, registerIoC } from './ioc/register';
+import { container, registerIoC } from './ioc/register-legacy';
 
 export function boot() {
   // Register the container
   registerIoC();
 
   //  getExternalUserData has type "(id: number): IUser" as we curried out the apiKey param
-  const getExternalUserData = container.get('getExternalUserData');
+  const getExternalUserData1 = container.get('getExternalUserData1');
 
-  const userData = getExternalUserData(23);
+  const userData = getExternalUserData1(23);
   return userData;
 }
 

package/lib/binder-legacy.d.ts

@@ -0,0 +1,9 @@
+import { Binder } from './binder';
+import { NewableOf, TupleToKeysOfMapped } from './types';
+/** @deprecated LEGACY: Using older method of class binding */
+export declare class LegacyBinder<T, TItem, TDep> extends Binder<T, TItem, TDep> {
+    /** Register a class */
+    classOld<C extends NewableOf<TItem>>(cls: C): {
+        construct(keys: TupleToKeysOfMapped<ConstructorParameters<C>, T & TDep>): import("./inversify").BindingInWhenOnSyntax<InstanceType<C>>;
+    };
+}

package/lib/binder-legacy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyBinder = void 0;
+var tslib_1 = require("tslib");
+var binder_1 = require("./binder");
+var inversify_1 = require("./inversify");
+/** @deprecated LEGACY: Using older method of class binding */
+var LegacyBinder = /** @class */ (function (_super) {
+    tslib_1.__extends(LegacyBinder, _super);
+    function LegacyBinder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /** Register a class */
+    LegacyBinder.prototype.classOld = function (cls) {
+        var k = this.key;
+        var t = this.keyTransformer;
+        return {
+            construct: function (keys) {
+                var keys1 = keys;
+                return (0, inversify_1.registerClass)(k, cls, keys1.map(t));
+            },
+        };
+    };
+    return LegacyBinder;
+}(binder_1.Binder));
+exports.LegacyBinder = LegacyBinder;

package/lib/binder.d.ts

@@ -0,0 +1,22 @@
+import { Curried1, Param1 } from './curry.generated';
+import { Func, IFunctionResolver } from './tail.generated';
+import { NewableOf, TupleToKeysOfMapped } from './types';
+declare type CollectCurriedParams<TOriginal extends Func, TCurried, TCollect extends any[] = []> = TOriginal extends TCurried ? TCollect : CollectCurriedParams<Curried1<TOriginal>, TCurried, [...TCollect, Param1<Parameters<TOriginal>>]>;
+export declare class Binder<T, TItem, TDep> {
+    protected key: string;
+    protected keyTransformer: (keyName: string) => string;
+    constructor(key: string, keyTransformer: (keyName: string) => string);
+    /** Gets the underlying container binding to the specified key */
+    get binding(): import("inversify/dts/interfaces/interfaces").interfaces.BindingToSyntax<TItem>;
+    /** Register a function */
+    function(item: TItem): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a function resolver */
+    functionResolver(item: IFunctionResolver<TItem>): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a constant */
+    constant(item: TItem): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a curried function */
+    functionCurry<TFn extends Func>(item: TFn, params: TupleToKeysOfMapped<CollectCurriedParams<TFn, TItem>, T & TDep>): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a class */
+    class<C extends NewableOf<TItem>>(cls: C, params: TupleToKeysOfMapped<ConstructorParameters<C>, T & TDep>): import("./inversify").BindingInWhenOnSyntax<InstanceType<C>>;
+}
+export {};

package/lib/binder.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Binder = void 0;
+var tslib_1 = require("tslib");
+var curry_1 = require("./curry");
+var inversify_1 = require("./inversify");
+var internalContainer = (0, inversify_1.getGlobalContainer)();
+var Binder = /** @class */ (function () {
+    function Binder(key, keyTransformer) {
+        this.key = key;
+        this.keyTransformer = keyTransformer;
+    }
+    Object.defineProperty(Binder.prototype, "binding", {
+        /** Gets the underlying container binding to the specified key */
+        get: function () {
+            return internalContainer.bind(this.key);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Register a function */
+    Binder.prototype.function = function (item) {
+        return this.binding.toFunction(item);
+    };
+    /** Register a function resolver */
+    Binder.prototype.functionResolver = function (item) {
+        return this.binding.toFactory(function () { return item.resolved(); });
+    };
+    /** Register a constant */
+    Binder.prototype.constant = function (item) {
+        return this.binding.toConstantValue(item);
+    };
+    /** Register a curried function */
+    Binder.prototype.functionCurry = function (item, params) {
+        var keys = params;
+        return this.functionResolver(curry_1.curryInner.apply(void 0, tslib_1.__spreadArray([item], keys.map(this.keyTransformer), false)));
+    };
+    /** Register a class */
+    Binder.prototype.class = function (cls, params) {
+        var keys = params;
+        return (0, inversify_1.registerClass)(this.key, cls, keys.map(this.keyTransformer));
+    };
+    return Binder;
+}());
+exports.Binder = Binder;

package/lib/curry.d.ts

@@ -0,0 +1,2 @@
+import { Func, IFunctionResolver } from './tail.generated';
+export declare function curryInner<TFn extends Func>(fn: TFn, ...keys: PropertyKey[]): IFunctionResolver<any>;

package/lib/curry.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curryInner = void 0;
+var tslib_1 = require("tslib");
+var inversify_1 = require("./inversify");
+var internalContainer = (0, inversify_1.getGlobalContainer)();
+function curryInner(fn) {
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    var curried;
+    return {
+        resolved: function () {
+            if (!curried) {
+                var values_1 = keys.map(function (k) { return internalContainer.get(k); });
+                curried = function () {
+                    var p = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        p[_i] = arguments[_i];
+                    }
+                    return fn.apply(fn, tslib_1.__spreadArray(tslib_1.__spreadArray([], values_1, true), p, true));
+                };
+            }
+            return curried;
+        },
+    };
+}
+exports.curryInner = curryInner;